@e-mc/core 0.11.8 → 0.12.1

package/README.md

@@ -1,7 +1,7 @@
 # @e-mc/core
 
-* NodeJS 16 LTS
-* ES2021
+* NodeJS 18
+* ES2022
 
 ## General Usage
 
@@ -9,19 +9,22 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.11.8/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.12.1/lib/index.d.ts)
 
 ```typescript
-import type { DataSource, LogStatus } from "./squared";
+import type { DataSource, LogStatus, WorkerAction } from "./squared";
 
 import type { IHost, IModule, ModuleConstructor } from "./index";
-import type { CacheOptions, HostInitConfig, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, StoreResultOptions, ThreadCountStat } from "./core";
+import type { AddEventListenerOptions, CacheOptions, HostInitConfig, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, StoreResultOptions, ThreadCountStat, WorkerChannelError, WorkerChannelResponse } from "./core";
 import type { QueryResult, TimeoutAction } from "./db";
-import type { AddEventListenerOptions } from "./dom";
 import type { LogState, StatusType } from "./logger";
 import type { Settings } from "./node";
 import type { ClientDbSettings, ClientModule, ClientSettings, DbCacheValue, DbCoerceSettings, DbCoerceValue, DbSourceOptions } from "./settings";
 
+import type { TransferListItem, Worker, WorkerOptions } from "node:worker_threads";
+
+import type * as EventEmitter from "node:events";
+
 interface IHost extends IModule {
     restartable: boolean;
     readonly modules: Set<IModule>;
@@ -64,6 +67,8 @@ interface HostConstructor extends ModuleConstructor {
     loadSettings(settings: Settings, permission?: PermissionReadWrite, password?: string): boolean;
     isPermission(value: unknown): value is IPermission;
     createPermission(all?: boolean, freeze?: boolean): IPermission;
+    kill(username: string, all: true): number;
+    kill(username: string, pid: number | number[]): number;
     kill(username: string, iv: BinaryLike, all: true): number;
     kill(username: string, iv: BinaryLike, pid: number | number[]): number;
     getThreadCount(full: true): ThreadCountStat;
@@ -139,6 +144,80 @@ interface ClientDbConstructor extends ClientConstructor<IHost, ClientModule> {
     new(module?: ClientModule, database?: DataSource[]): IClientDb;
 }
 
+interface IWorkerGroup {
+    [Symbol.iterator](): IteratorObject<IWorkerChannel, BuiltinIteratorReturn>;
+    add(name: string, item: IWorkerChannel, priority?: number): this;
+    get(name: string, force?: boolean | number): IWorkerChannel | undefined;
+    delete(name: string | IWorkerChannel): boolean;
+    free(count?: number): number;
+    print(format: "stats" | "errors"): void;
+    clear(): void;
+    set max(value);
+    get max(): number;
+    get workers(): IWorkerChannel[];
+    get pending(): number;
+    get available(): number;
+    get errors(): WorkerChannelError[];
+    get size(): number;
+    get sizeOf(): number;
+}
+
+interface WorkerGroupConstructor {
+    checkTimeout(value: number, active?: boolean): number;
+    readonly prototype: IWorkerGroup;
+    new(max?: number, locked?: boolean): IWorkerGroup;
+}
+
+interface IWorkerChannel extends EventEmitter {
+    [Symbol.iterator](): IteratorObject<Worker, BuiltinIteratorReturn>;
+    sendObject(data: unknown, transferList?: TransferListItem[], callback?: WorkerChannelResponse<unknown>, ...returnArgs: unknown[]): Worker;
+    sendBuffer(data: Buffer, shared?: boolean, callback?: WorkerChannelResponse<unknown>, ...returnArgs: unknown[]): Worker | null;
+    send(data: unknown, transferList?: TransferListItem[]): Promise<unknown>;
+    drop(count?: number): Promise<number>;
+    join(group: IWorkerGroup, label?: string): void;
+    quit(): void;
+    kill(count?: number): Promise<number>;
+    lock(): void;
+    isEmpty(): boolean;
+    set min(value);
+    get min(): number;
+    set max(value);
+    get max(): number;
+    set timeoutMs(value);
+    get timeoutMs(): number;
+    get filename(): string;
+    get workers(): Worker[];
+    get detached(): boolean;
+    get lastAccessed(): Date;
+    get timesAccessed(): number;
+    get frequencyAccessed(): number;
+    get pending(): number;
+    get available(): number;
+    get size(): number;
+
+    /* EventEmitter */
+    on(event: "error" | "messageerror" | "abort", listener: (err: Error) => void): this;
+    on(event: "exit", listener: (exitCode: number) => void): this;
+    on(event: "online", listener: () => void): this;
+    on(event: "message", listener: (value: any) => void): this;
+    on(event: "data", listener: (data: unknown) => void): this;
+    on(event: "pass", listener: (data: unknown, transferList: TransferListItem[] | undefined) => void): this;
+    once(event: "error" | "messageerror" | "abort", listener: (err: Error) => void): this;
+    once(event: "exit", listener: (exitCode: number) => void): this;
+    once(event: "online", listener: () => void): this;
+    once(event: "message", listener: (value: any) => void): this;
+    once(event: "data", listener: (data: unknown) => void): this;
+    once(event: "pass", listener: (data: unknown, transferList: TransferListItem[] | undefined) => void): this;
+}
+
+interface WorkerChannelConstructor {
+    create(filename: string, name: string): IWorkerChannel;
+    create(filename: string, options?: WorkerOptions, name?: string): IWorkerChannel;
+    hasPermission(options?: WorkerAction): boolean;
+    readonly prototype: IWorkerChannel;
+    new(filename: string, max?: number, timeoutMs?: number): IWorkerChannel;
+}
+
 interface IAbortComponent extends AbortController {
     reset(): void;
     get aborted(): boolean;
@@ -152,9 +231,13 @@ interface AbortComponentConstructor {
 }
 
 interface IPermission {
+    setDiskRead(enabled: boolean): void;
     setDiskRead(pathname?: string | string[], enabled?: boolean): void;
+    setDiskWrite(enabled: boolean): void;
     setDiskWrite(pathname?: string | string[], enabled?: boolean): void;
+    setUNCRead(enabled: boolean): void;
     setUNCRead(pathname?: string | string[], enabled?: boolean): void;
+    setUNCWrite(enabled: boolean): void;
     setUNCWrite(pathname?: string | string[], enabled?: boolean): void;
     getDiskRead(): string | string[];
     getDiskWrite(): string | string[];
@@ -194,6 +277,9 @@ interface ProcessModule {
                 max?: number;
             };
         };
+        workers?: {
+            channel?: { min?: number; max?: number; expires?: number | string };
+        };
         limit?: number;
         expires?: number | string;
     };
@@ -232,13 +318,15 @@ NOTE: **@e-mc/core** is mostly a collection of abstract base classes which canno
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/squared.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/core.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/db.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/dom.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/node.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/squared.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/core.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/db.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/dom.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/settings.d.ts
+
+* https://www.npmjs.com/package/@types/node
 
 ## LICENSE
 

package/index.d.ts

@@ -1,11 +1,13 @@
 import type { HostConstructor, ModuleConstructor } from '@e-mc/types/lib';
-import type { AbortComponentConstructor, ClientConstructor, ClientDbConstructor, PermissionConstructor } from '@e-mc/types/lib/core';
+import type { AbortComponentConstructor, ClientConstructor, ClientDbConstructor, PermissionConstructor, WorkerChannelConstructor, WorkerGroupConstructor } from '@e-mc/types/lib/core';
 
 declare namespace core {
     const Module: ModuleConstructor;
     const Host: HostConstructor;
     const Client: ClientConstructor;
     const ClientDb: ClientDbConstructor;
+    const WorkerGroup: WorkerGroupConstructor;
+    const WorkerChannel: WorkerChannelConstructor;
     const AbortComponent: AbortComponentConstructor;
     const Permission: PermissionConstructor;
 }