Socket
Socket
Sign inDemoInstall

@simplysm/sd-core-common

Package Overview
Dependencies
Maintainers
1
Versions
605
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@simplysm/sd-core-common - npm Package Compare versions

Comparing version 11.3.10 to 11.3.11

13

dist/utils/FunctionQueue.d.ts

@@ -1,8 +0,11 @@

export declare class FunctionQueue {
private readonly _gap?;
private readonly _queue;
private _isQueueRunning;
constructor(_gap?: number | undefined);
/// <reference types="node" />
import EventEmitter from "events";
export declare class FunctionQueue extends EventEmitter {
#private;
on(event: "start", listener: () => void): this;
on(event: "end", listener: () => void): this;
on(event: "error", listener: (err: Error) => void): this;
constructor(gap?: number);
run(fn: () => void | Promise<void>): void;
runLast(fn: () => void | Promise<void>): void;
}

@@ -0,43 +1,64 @@

import EventEmitter from "events";
import { Wait } from "./Wait";
export class FunctionQueue {
constructor(_gap) {
this._gap = _gap;
this._queue = [];
this._isQueueRunning = false;
export class FunctionQueue extends EventEmitter {
#queue = [];
#isRunning = false;
#gap;
on(event, listener) {
super.on(event, listener);
return this;
}
constructor(gap = 0) {
super();
this.#gap = gap;
}
run(fn) {
this._queue.push(fn);
if (this._isQueueRunning)
this.#queue.push(fn);
if (this.#isRunning)
return;
void (async () => {
this._isQueueRunning = true;
this.#isRunning = true;
while (true) {
const runningFn = this._queue.shift();
const runningFn = this.#queue.shift();
if (!runningFn)
break;
await runningFn();
if (this._gap !== undefined && this._gap > 0) {
await Wait.time(this._gap);
this.emit("start");
try {
await runningFn();
}
catch (err) {
this.emit("error", err);
}
this.emit("end");
if (this.#gap > 0) {
await Wait.time(this.#gap);
}
}
this._isQueueRunning = false;
this.#isRunning = false;
})();
}
runLast(fn) {
this._queue.push(fn);
if (this._isQueueRunning)
this.#queue.push(fn);
if (this.#isRunning)
return;
void (async () => {
this._isQueueRunning = true;
this.#isRunning = true;
while (true) {
const runningFn = this._queue.last();
this._queue.clear();
const runningFn = this.#queue.last();
this.#queue.clear();
if (!runningFn)
break;
await runningFn();
if (this._gap !== undefined && this._gap > 0) {
await Wait.time(this._gap);
this.emit("start");
try {
await runningFn();
}
catch (err) {
this.emit("error", err);
}
this.emit("end");
if (this.#gap > 0) {
await Wait.time(this.#gap);
}
}
this._isQueueRunning = false;
this.#isRunning = false;
})();

@@ -44,0 +65,0 @@ }

{
"name": "@simplysm/sd-core-common",
"version": "11.3.10",
"version": "11.3.11",
"description": "심플리즘 패키지 - 코어 모듈 (common)",

@@ -5,0 +5,0 @@ "author": "김석래",

@@ -0,47 +1,74 @@

import EventEmitter from "events";
import {Wait} from "./Wait";
export class FunctionQueue {
private readonly _queue: (() => void | Promise<void>)[] = [];
private _isQueueRunning = false;
export class FunctionQueue extends EventEmitter {
#queue: (() => void | Promise<void>)[] = [];
#isRunning = false;
public constructor(private readonly _gap?: number) {
#gap: number;
override on(event: "start", listener: () => void): this;
override on(event: "end", listener: () => void): this;
override on(event: "error", listener: (err: Error) => void): this;
override on(event: string | symbol, listener: (...args: any[]) => void): this {
super.on(event, listener);
return this;
}
public run(fn: () => void | Promise<void>): void {
this._queue.push(fn);
if (this._isQueueRunning) return;
constructor(gap: number = 0) {
super();
this.#gap = gap;
}
run(fn: () => void | Promise<void>): void {
this.#queue.push(fn);
if (this.#isRunning) return;
void (async () => {
this._isQueueRunning = true;
this.#isRunning = true;
while (true) {
const runningFn = this._queue.shift();
const runningFn = this.#queue.shift();
if (!runningFn) break;
await runningFn();
if (this._gap !== undefined && this._gap > 0) {
await Wait.time(this._gap);
this.emit("start");
try {
await runningFn();
}
catch (err) {
this.emit("error", err);
}
this.emit("end");
if (this.#gap > 0) {
await Wait.time(this.#gap);
}
}
this._isQueueRunning = false;
this.#isRunning = false;
})();
}
public runLast(fn: () => void | Promise<void>): void {
this._queue.push(fn);
if (this._isQueueRunning) return;
runLast(fn: () => void | Promise<void>): void {
this.#queue.push(fn);
if (this.#isRunning) return;
void (async () => {
this._isQueueRunning = true;
this.#isRunning = true;
while (true) {
const runningFn = this._queue.last();
this._queue.clear();
const runningFn = this.#queue.last();
this.#queue.clear();
if (!runningFn) break;
await runningFn();
if (this._gap !== undefined && this._gap > 0) {
await Wait.time(this._gap);
this.emit("start");
try {
await runningFn();
}
catch (err) {
this.emit("error", err);
}
this.emit("end");
if (this.#gap > 0) {
await Wait.time(this.#gap);
}
}
this._isQueueRunning = false;
this.#isRunning = false;
})();
}
}

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc