@sapphire-sh/utils 1.39.0 → 1.40.0

package/lib/eslint.d.ts

@@ -1,24 +1,2 @@
-declare const config: ({
-    readonly rules: Readonly<import("eslint").Linter.RulesRecord>;
-} | import("typescript-eslint/dist/compatibility-types").CompatibleConfig | {
-    rules: {
-        '@typescript-eslint/no-floating-promises': string;
-        '@typescript-eslint/no-misused-promises': string;
-        '@typescript-eslint/no-unnecessary-condition': string;
-        '@typescript-eslint/switch-exhaustiveness-check': string;
-        '@typescript-eslint/return-await': string[];
-        '@typescript-eslint/prefer-readonly': string;
-        '@typescript-eslint/strict-boolean-expressions': string;
-    };
-    languageOptions: {
-        parserOptions: {
-            project: boolean;
-        };
-    };
-    ignores?: undefined;
-} | {
-    ignores: string[];
-    rules?: undefined;
-    languageOptions?: undefined;
-})[];
-export default config;
+declare const _default: import("@eslint/config-helpers").Config[];
+export default _default;

package/lib/eslint.js

@@ -5,72 +5,65 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const js_1 = __importDefault(require("@eslint/js"));
 const eslint_config_prettier_1 = __importDefault(require("eslint-config-prettier"));
+const config_1 = require("eslint/config");
 const typescript_eslint_1 = __importDefault(require("typescript-eslint"));
-const config = [
-    js_1.default.configs.recommended,
-    ...typescript_eslint_1.default.configs.recommended,
-    eslint_config_prettier_1.default,
-    {
-        rules: {
-            // General
-            'no-console': 'off',
-            'no-constant-condition': ['error', { checkLoops: false }],
-            'no-var': 'error',
-            'no-throw-literal': 'error',
-            'no-param-reassign': 'error',
-            'no-nested-ternary': 'error',
-            'no-unneeded-ternary': 'error',
-            'prefer-const': 'error',
-            'prefer-template': 'error',
-            'prefer-destructuring': 'error',
-            'prefer-arrow-callback': 'error',
-            'eqeqeq': ['error', 'always'],
-            'object-shorthand': 'error',
-            'no-else-return': 'error',
-            'arrow-body-style': ['error', 'as-needed'],
-            'func-style': ['error', 'expression'],
-            'yoda': 'error',
-            // TypeScript
-            '@typescript-eslint/no-unused-vars': ['error', { varsIgnorePattern: '^_', argsIgnorePattern: '^_' }],
-            '@typescript-eslint/naming-convention': [
-                'error',
-                {
-                    selector: 'interface',
-                    format: ['PascalCase'],
-                    custom: { regex: '^I[A-Z]', match: false },
-                },
-            ],
-            '@typescript-eslint/no-namespace': 'off',
-            '@typescript-eslint/no-shadow': 'off',
-            '@typescript-eslint/consistent-type-imports': 'error',
-            '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
-            '@typescript-eslint/no-explicit-any': 'warn',
-            '@typescript-eslint/no-non-null-assertion': 'warn',
-            '@typescript-eslint/no-unnecessary-type-assertion': 'error',
-            '@typescript-eslint/array-type': ['error', { default: 'array' }],
-            '@typescript-eslint/prefer-nullish-coalescing': 'error',
-            '@typescript-eslint/prefer-optional-chain': 'error',
-        },
-    },
-    {
-        // Type-aware rules (requires parserOptions.project in consumer config)
-        rules: {
-            '@typescript-eslint/no-floating-promises': 'error',
-            '@typescript-eslint/no-misused-promises': 'error',
-            '@typescript-eslint/no-unnecessary-condition': 'error',
-            '@typescript-eslint/switch-exhaustiveness-check': 'error',
-            '@typescript-eslint/return-await': ['error', 'in-try-catch'],
-            '@typescript-eslint/prefer-readonly': 'error',
-            '@typescript-eslint/strict-boolean-expressions': 'error',
-        },
-        languageOptions: {
-            parserOptions: {
-                project: true,
+exports.default = (0, config_1.defineConfig)(js_1.default.configs.recommended, ...typescript_eslint_1.default.configs.recommended, eslint_config_prettier_1.default, {
+    rules: {
+        // General
+        'no-console': 'off',
+        'no-constant-condition': ['error', { checkLoops: false }],
+        'no-var': 'error',
+        'no-throw-literal': 'error',
+        'no-param-reassign': 'error',
+        'no-nested-ternary': 'error',
+        'no-unneeded-ternary': 'error',
+        'prefer-const': 'error',
+        'prefer-template': 'error',
+        'prefer-destructuring': 'error',
+        'prefer-arrow-callback': 'error',
+        eqeqeq: ['error', 'always'],
+        'object-shorthand': 'error',
+        'no-else-return': 'error',
+        'arrow-body-style': ['error', 'as-needed'],
+        'func-style': ['error', 'expression'],
+        yoda: 'error',
+        // TypeScript
+        '@typescript-eslint/no-unused-vars': ['error', { varsIgnorePattern: '^_', argsIgnorePattern: '^_' }],
+        '@typescript-eslint/naming-convention': [
+            'error',
+            {
+                selector: 'interface',
+                format: ['PascalCase'],
+                custom: { regex: '^I[A-Z]', match: false },
             },
-        },
+        ],
+        '@typescript-eslint/no-namespace': 'off',
+        '@typescript-eslint/no-shadow': 'off',
+        '@typescript-eslint/consistent-type-imports': 'error',
+        '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+        '@typescript-eslint/no-explicit-any': 'warn',
+        '@typescript-eslint/no-non-null-assertion': 'warn',
+        '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+        '@typescript-eslint/array-type': ['error', { default: 'array' }],
+        '@typescript-eslint/prefer-nullish-coalescing': 'error',
+        '@typescript-eslint/prefer-optional-chain': 'error',
+    },
+}, {
+    // Type-aware rules (requires parserOptions.project in consumer config)
+    rules: {
+        '@typescript-eslint/no-floating-promises': 'error',
+        '@typescript-eslint/no-misused-promises': 'error',
+        '@typescript-eslint/no-unnecessary-condition': 'error',
+        '@typescript-eslint/switch-exhaustiveness-check': 'error',
+        '@typescript-eslint/return-await': ['error', 'in-try-catch'],
+        '@typescript-eslint/prefer-readonly': 'error',
+        '@typescript-eslint/strict-boolean-expressions': 'error',
     },
-    {
-        ignores: ['**/*.json', 'node_modules/'],
+    languageOptions: {
+        parserOptions: {
+            project: true,
+        },
     },
-];
-exports.default = config;
+}, {
+    ignores: ['**/*.json', 'node_modules/', 'coverage/', 'lib/'],
+});

package/lib/esm/eslint.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint/config").Config[];
+export default _default;

package/lib/esm/eslint.js

@@ -0,0 +1,64 @@
+import eslint from '@eslint/js';
+import prettier from 'eslint-config-prettier';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+export default defineConfig(eslint.configs.recommended, ...tseslint.configs.recommended, prettier, {
+    rules: {
+        // General
+        'no-console': 'off',
+        'no-constant-condition': ['error', { checkLoops: false }],
+        'no-var': 'error',
+        'no-throw-literal': 'error',
+        'no-param-reassign': 'error',
+        'no-nested-ternary': 'error',
+        'no-unneeded-ternary': 'error',
+        'prefer-const': 'error',
+        'prefer-template': 'error',
+        'prefer-destructuring': 'error',
+        'prefer-arrow-callback': 'error',
+        eqeqeq: ['error', 'always'],
+        'object-shorthand': 'error',
+        'no-else-return': 'error',
+        'arrow-body-style': ['error', 'as-needed'],
+        'func-style': ['error', 'expression'],
+        yoda: 'error',
+        // TypeScript
+        '@typescript-eslint/no-unused-vars': ['error', { varsIgnorePattern: '^_', argsIgnorePattern: '^_' }],
+        '@typescript-eslint/naming-convention': [
+            'error',
+            {
+                selector: 'interface',
+                format: ['PascalCase'],
+                custom: { regex: '^I[A-Z]', match: false },
+            },
+        ],
+        '@typescript-eslint/no-namespace': 'off',
+        '@typescript-eslint/no-shadow': 'off',
+        '@typescript-eslint/consistent-type-imports': 'error',
+        '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+        '@typescript-eslint/no-explicit-any': 'warn',
+        '@typescript-eslint/no-non-null-assertion': 'warn',
+        '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+        '@typescript-eslint/array-type': ['error', { default: 'array' }],
+        '@typescript-eslint/prefer-nullish-coalescing': 'error',
+        '@typescript-eslint/prefer-optional-chain': 'error',
+    },
+}, {
+    // Type-aware rules (requires parserOptions.project in consumer config)
+    rules: {
+        '@typescript-eslint/no-floating-promises': 'error',
+        '@typescript-eslint/no-misused-promises': 'error',
+        '@typescript-eslint/no-unnecessary-condition': 'error',
+        '@typescript-eslint/switch-exhaustiveness-check': 'error',
+        '@typescript-eslint/return-await': ['error', 'in-try-catch'],
+        '@typescript-eslint/prefer-readonly': 'error',
+        '@typescript-eslint/strict-boolean-expressions': 'error',
+    },
+    languageOptions: {
+        parserOptions: {
+            project: true,
+        },
+    },
+}, {
+    ignores: ['**/*.json', 'node_modules/', 'coverage/', 'lib/'],
+});

package/lib/esm/getEnumValue.d.ts

@@ -0,0 +1 @@
+export declare const getEnumValue: <T extends string, TEnum extends string>(value: { [key in T]: TEnum; }) => (value?: string) => TEnum | null;

package/lib/esm/getEnumValue.js

@@ -0,0 +1,4 @@
+export const getEnumValue = (value) => {
+    const enumValues = Object.values(value);
+    return (value) => (enumValues.includes(value) ? value : null);
+};

package/lib/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { getEnumValue } from './getEnumValue';
+export { isNonNullable } from './isNonNullable';
+export { LogLevel, logger } from './logger';
+export { notifyMattermost, notifySlack } from './notify';
+export { Queue } from './queue';
+export { sleep } from './sleep';
+export { throttle } from './throttle';

package/lib/esm/index.js

@@ -0,0 +1,7 @@
+export { getEnumValue } from './getEnumValue';
+export { isNonNullable } from './isNonNullable';
+export { LogLevel, logger } from './logger';
+export { notifyMattermost, notifySlack } from './notify';
+export { Queue } from './queue';
+export { sleep } from './sleep';
+export { throttle } from './throttle';

package/lib/esm/isNonNullable.d.ts

@@ -0,0 +1 @@
+export declare const isNonNullable: <T>(value?: T | null) => value is NonNullable<T>;

package/lib/esm/isNonNullable.js

@@ -0,0 +1,9 @@
+export const isNonNullable = (value) => {
+    if (value === null) {
+        return false;
+    }
+    if (value === undefined) {
+        return false;
+    }
+    return true;
+};

package/lib/esm/logger.d.ts

@@ -0,0 +1,15 @@
+export declare enum LogLevel {
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4
+}
+type Payload = Record<string, unknown> | Error;
+export declare const logger: {
+    debug: (message: string, payload?: Payload) => void;
+    info: (message: string, payload?: Payload) => void;
+    warn: (message: string, payload?: Payload) => void;
+    error: (message: string, payload?: Payload) => void;
+    setLevel: (level: LogLevel | string) => void;
+};
+export {};

package/lib/esm/logger.js

@@ -0,0 +1,52 @@
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+const serializePayload = (payload) => {
+    const json = JSON.stringify(payload instanceof Error ? { error: payload.message, name: payload.name, stack: payload.stack } : payload);
+    return json.padStart(json.length + 1);
+};
+let currentLevel = LogLevel.INFO;
+const log = (level, message, payload) => {
+    if (level < currentLevel) {
+        return;
+    }
+    const ts = new Date().toISOString();
+    const prefix = `[${ts}] [${LogLevel[level].toUpperCase()}]`;
+    const payloadStr = payload === undefined ? '' : serializePayload(payload);
+    const output = `${prefix} ${message}${payloadStr}`;
+    if (level === LogLevel.ERROR) {
+        console.error(output);
+    }
+    else if (level === LogLevel.WARN) {
+        console.warn(output);
+    }
+    else if (level === LogLevel.DEBUG) {
+        console.debug(output);
+    }
+    else {
+        console.log(output);
+    }
+};
+export const logger = {
+    debug: (message, payload) => log(LogLevel.DEBUG, message, payload),
+    info: (message, payload) => log(LogLevel.INFO, message, payload),
+    warn: (message, payload) => log(LogLevel.WARN, message, payload),
+    error: (message, payload) => log(LogLevel.ERROR, message, payload),
+    setLevel: (level) => {
+        if (typeof level === 'string') {
+            const resolved = LogLevel[level.toUpperCase()];
+            if (resolved === undefined) {
+                console.warn(`[logger] Invalid log level: "${level}", keeping current level`);
+                return;
+            }
+            currentLevel = resolved;
+        }
+        else {
+            currentLevel = level;
+        }
+    },
+};

package/lib/esm/notify.d.ts

@@ -0,0 +1,2 @@
+export declare const notifySlack: (url: string, text: string) => Promise<void>;
+export declare const notifyMattermost: (baseUrl: string, token: string, channelId: string, message: string) => Promise<void>;

package/lib/esm/notify.js

@@ -0,0 +1,30 @@
+import { logger } from './logger';
+export const notifySlack = async (url, text) => {
+    logger.debug('[notifySlack] posting to webhook', { textLength: text.length });
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ text }),
+    });
+    logger.debug('[notifySlack] response received', { status: resp.status });
+    if (!resp.ok) {
+        throw new Error(`Slack webhook failed: HTTP ${resp.status}`);
+    }
+};
+export const notifyMattermost = async (baseUrl, token, channelId, message) => {
+    logger.debug('[notifyMattermost] posting to channel', { channelId, messageLength: message.length });
+    const resp = await fetch(`${baseUrl}/api/v4/posts`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ channel_id: channelId, message }),
+    });
+    logger.debug('[notifyMattermost] response received', { status: resp.status });
+    if (!resp.ok) {
+        throw new Error(`Mattermost post failed: HTTP ${resp.status}`);
+    }
+};

package/lib/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/esm/prettier.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'prettier';
+declare const config: Config;
+export default config;

package/lib/esm/prettier.js

@@ -0,0 +1,12 @@
+const config = {
+    singleQuote: true,
+    semi: true,
+    tabWidth: 2,
+    useTabs: true,
+    printWidth: 120,
+    trailingComma: 'all',
+    arrowParens: 'always',
+    endOfLine: 'lf',
+    plugins: ['prettier-plugin-organize-imports'],
+};
+export default config;

package/lib/esm/queue.d.ts

@@ -0,0 +1,16 @@
+type Value = object | number | string | boolean;
+export declare class Queue<T extends Value> {
+    private head;
+    private tail;
+    private _size;
+    enqueue(value: T): void;
+    dequeue(): T | undefined;
+    dequeueMultiple(count: number): T[];
+    get size(): number;
+    isEmpty(): boolean;
+    peek(): T | undefined;
+    has(value: T): boolean;
+    some(predicate: (value: T) => boolean): boolean;
+    toArray(): T[];
+}
+export {};

package/lib/esm/queue.js

@@ -0,0 +1,94 @@
+class QueueNode {
+    value;
+    _next = null;
+    constructor(value) {
+        this.value = value;
+    }
+    get next() {
+        return this._next;
+    }
+    setNext(newNode) {
+        this._next = newNode;
+    }
+}
+export class Queue {
+    head = null;
+    tail = null;
+    _size = 0;
+    enqueue(value) {
+        const newNode = new QueueNode(value);
+        if (this.isEmpty() || !this.tail) {
+            this.head = newNode;
+            this.tail = newNode;
+        }
+        else {
+            this.tail.setNext(newNode);
+            this.tail = newNode;
+        }
+        this._size += 1;
+    }
+    dequeue() {
+        if (this.isEmpty() || !this.head) {
+            return;
+        }
+        const { value } = this.head;
+        this.head = this.head.next;
+        this._size -= 1;
+        if (this.isEmpty()) {
+            this.tail = null;
+        }
+        return value;
+    }
+    dequeueMultiple(count) {
+        const array = [];
+        for (let i = 0; i < count; ++i) {
+            const value = this.dequeue();
+            if (value === undefined) {
+                break;
+            }
+            array.push(value);
+        }
+        return array;
+    }
+    get size() {
+        return this._size;
+    }
+    isEmpty() {
+        return this._size === 0;
+    }
+    peek() {
+        return this.head?.value;
+    }
+    has(value) {
+        let node = this.head;
+        while (node !== null) {
+            if (node.value === value) {
+                return true;
+            }
+            node = node.next;
+        }
+        return false;
+    }
+    some(predicate) {
+        let node = this.head;
+        while (node !== null) {
+            if (predicate(node.value)) {
+                return true;
+            }
+            node = node.next;
+        }
+        return false;
+    }
+    toArray() {
+        let node = this.head;
+        if (!node) {
+            return [];
+        }
+        const array = [];
+        while (node) {
+            array.push(node.value);
+            node = node.next;
+        }
+        return array;
+    }
+}

package/lib/esm/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number, jitter?: number) => Promise<void>;

package/lib/esm/sleep.js

@@ -0,0 +1,4 @@
+export const sleep = (ms, jitter = 0) => {
+    const delay = ms + Math.random() * jitter;
+    return new Promise((resolve) => globalThis.setTimeout(resolve, delay));
+};

package/lib/esm/throttle.d.ts

@@ -0,0 +1 @@
+export declare const throttle: <T, R>(fn: (...args: T[]) => R, interval: number) => (...args: T[]) => R | undefined;

package/lib/esm/throttle.js

@@ -0,0 +1,11 @@
+export const throttle = (fn, interval) => {
+    let timestamp = 0;
+    return (...args) => {
+        const now = Date.now();
+        if (now - timestamp < interval) {
+            return;
+        }
+        timestamp = now;
+        return fn(...args);
+    };
+};

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 export { getEnumValue } from './getEnumValue';
 export { isNonNullable } from './isNonNullable';
-export { logger, LogLevel } from './logger';
-export { Queue } from './queue';
+export { LogLevel, logger } from './logger';
 export { notifyMattermost, notifySlack } from './notify';
+export { Queue } from './queue';
 export { sleep } from './sleep';
 export { throttle } from './throttle';

package/lib/index.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throttle = exports.sleep = exports.notifySlack = exports.notifyMattermost = exports.Queue = exports.LogLevel = exports.logger = exports.isNonNullable = exports.getEnumValue = void 0;
+exports.throttle = exports.sleep = exports.Queue = exports.notifySlack = exports.notifyMattermost = exports.logger = exports.LogLevel = exports.isNonNullable = exports.getEnumValue = void 0;
 var getEnumValue_1 = require("./getEnumValue");
 Object.defineProperty(exports, "getEnumValue", { enumerable: true, get: function () { return getEnumValue_1.getEnumValue; } });
 var isNonNullable_1 = require("./isNonNullable");
 Object.defineProperty(exports, "isNonNullable", { enumerable: true, get: function () { return isNonNullable_1.isNonNullable; } });
 var logger_1 = require("./logger");
-Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
 Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
-var queue_1 = require("./queue");
-Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return queue_1.Queue; } });
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
 var notify_1 = require("./notify");
 Object.defineProperty(exports, "notifyMattermost", { enumerable: true, get: function () { return notify_1.notifyMattermost; } });
 Object.defineProperty(exports, "notifySlack", { enumerable: true, get: function () { return notify_1.notifySlack; } });
+var queue_1 = require("./queue");
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return queue_1.Queue; } });
 var sleep_1 = require("./sleep");
 Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return sleep_1.sleep; } });
 var throttle_1 = require("./throttle");

package/lib/logger.js

@@ -8,12 +8,12 @@ var LogLevel;
     LogLevel[LogLevel["WARN"] = 3] = "WARN";
     LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
-function serializePayload(payload) {
+const serializePayload = (payload) => {
     const json = JSON.stringify(payload instanceof Error ? { error: payload.message, name: payload.name, stack: payload.stack } : payload);
     return json.padStart(json.length + 1);
-}
+};
 let currentLevel = LogLevel.INFO;
-function log(level, message, payload) {
+const log = (level, message, payload) => {
     if (level < currentLevel) {
         return;
     }
@@ -33,7 +33,7 @@ function log(level, message, payload) {
     else {
         console.log(output);
     }
-}
+};
 exports.logger = {
     debug: (message, payload) => log(LogLevel.DEBUG, message, payload),
     info: (message, payload) => log(LogLevel.INFO, message, payload),

package/lib/notify.d.ts

@@ -1,2 +1,2 @@
-export declare function notifySlack(url: string, text: string): Promise<void>;
-export declare function notifyMattermost(baseUrl: string, token: string, channelId: string, message: string): Promise<void>;
+export declare const notifySlack: (url: string, text: string) => Promise<void>;
+export declare const notifyMattermost: (baseUrl: string, token: string, channelId: string, message: string) => Promise<void>;

package/lib/notify.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.notifySlack = notifySlack;
-exports.notifyMattermost = notifyMattermost;
+exports.notifyMattermost = exports.notifySlack = void 0;
 const logger_1 = require("./logger");
-async function notifySlack(url, text) {
+const notifySlack = async (url, text) => {
     logger_1.logger.debug('[notifySlack] posting to webhook', { textLength: text.length });
     const resp = await fetch(url, {
         method: 'POST',
@@ -16,13 +15,14 @@ async function notifySlack(url, text) {
     if (!resp.ok) {
         throw new Error(`Slack webhook failed: HTTP ${resp.status}`);
     }
-}
-async function notifyMattermost(baseUrl, token, channelId, message) {
+};
+exports.notifySlack = notifySlack;
+const notifyMattermost = async (baseUrl, token, channelId, message) => {
     logger_1.logger.debug('[notifyMattermost] posting to channel', { channelId, messageLength: message.length });
     const resp = await fetch(`${baseUrl}/api/v4/posts`, {
         method: 'POST',
         headers: {
-            'Authorization': `Bearer ${token}`,
+            Authorization: `Bearer ${token}`,
             'Content-Type': 'application/json',
         },
         body: JSON.stringify({ channel_id: channelId, message }),
@@ -31,4 +31,5 @@ async function notifyMattermost(baseUrl, token, channelId, message) {
     if (!resp.ok) {
         throw new Error(`Mattermost post failed: HTTP ${resp.status}`);
     }
-}
+};
+exports.notifyMattermost = notifyMattermost;

package/lib/queue.d.ts

@@ -9,7 +9,8 @@ export declare class Queue<T extends Value> {
     get size(): number;
     isEmpty(): boolean;
     peek(): T | undefined;
-    has(value: T | ((value: T) => boolean)): boolean;
+    has(value: T): boolean;
+    some(predicate: (value: T) => boolean): boolean;
     toArray(): T[];
 }
 export {};

package/lib/queue.js

@@ -34,7 +34,7 @@ class Queue {
         if (this.isEmpty() || !this.head) {
             return;
         }
-        const value = this.head.value;
+        const { value } = this.head;
         this.head = this.head.next;
         this._size -= 1;
         if (this.isEmpty()) {
@@ -46,7 +46,7 @@ class Queue {
         const array = [];
         for (let i = 0; i < count; ++i) {
             const value = this.dequeue();
-            if (!value) {
+            if (value === undefined) {
                 break;
             }
             array.push(value);
@@ -65,12 +65,17 @@ class Queue {
     has(value) {
         let node = this.head;
         while (node !== null) {
-            if (typeof value === 'function') {
-                if (value(node.value)) {
-                    return true;
-                }
+            if (node.value === value) {
+                return true;
             }
-            else if (node.value === value) {
+            node = node.next;
+        }
+        return false;
+    }
+    some(predicate) {
+        let node = this.head;
+        while (node !== null) {
+            if (predicate(node.value)) {
                 return true;
             }
             node = node.next;

package/package.json

@@ -1,74 +1,80 @@
 {
-  "name": "@sapphire-sh/utils",
-  "version": "1.39.0",
-  "description": "@sapphire-sh/utils",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "exports": {
-    ".": {
-      "require": "./lib/index.js",
-      "types": "./lib/index.d.ts"
-    },
-    "./eslint": {
-      "require": "./lib/eslint.js",
-      "types": "./lib/eslint.d.ts"
-    },
-    "./prettier": {
-      "require": "./lib/prettier.js",
-      "types": "./lib/prettier.d.ts"
-    }
-  },
-  "files": [
-    "lib/**/*"
-  ],
-  "scripts": {
-    "prebuild": "rm -fr ./lib",
-    "build": "tsc",
-    "prepare": "npm run build",
-    "test": "vitest run",
-    "coverage": "vitest run --coverage"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sapphire-sh/sapphire-utils.git"
-  },
-  "author": "sapphire",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/sapphire-sh/sapphire-utils/issues"
-  },
-  "homepage": "https://github.com/sapphire-sh/sapphire-utils#readme",
-  "peerDependencies": {
-    "@eslint/js": ">=9.0.0",
-    "eslint": ">=9.0.0",
-    "eslint-config-prettier": ">=9.0.0",
-    "prettier": ">=3.0.0",
-    "prettier-plugin-organize-imports": ">=4.0.0",
-    "typescript-eslint": ">=8.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@eslint/js": {
-      "optional": true
-    },
-    "eslint": {
-      "optional": true
-    },
-    "eslint-config-prettier": {
-      "optional": true
-    },
-    "typescript-eslint": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.24.0",
-    "@vitest/coverage-v8": "^4.1.1",
-    "eslint": "^9.24.0",
-    "eslint-config-prettier": "^10.1.2",
-    "prettier": "^3.8.1",
-    "prettier-plugin-organize-imports": "^4.3.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.29.1",
-    "vitest": "^4.1.1"
-  }
+	"name": "@sapphire-sh/utils",
+	"version": "1.40.0",
+	"description": "@sapphire-sh/utils",
+	"type": "module",
+	"main": "./lib/index.js",
+	"types": "./lib/index.d.ts",
+	"exports": {
+		".": {
+			"require": "./lib/index.js",
+			"types": "./lib/index.d.ts"
+		},
+		"./eslint": {
+			"import": "./lib/esm/eslint.js",
+			"require": "./lib/eslint.js",
+			"types": "./lib/eslint.d.ts"
+		},
+		"./prettier": {
+			"require": "./lib/prettier.js",
+			"types": "./lib/prettier.d.ts"
+		}
+	},
+	"files": [
+		"lib/**/*"
+	],
+	"scripts": {
+		"prebuild": "rm -fr ./lib",
+		"build": "tsc && tsc -p tsconfig.esm.json && printf '{\"type\":\"module\"}' > lib/esm/package.json",
+		"prepare": "npm run build",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"prettier": "prettier --check .",
+		"prettier:fix": "prettier --write .",
+		"test": "vitest run",
+		"coverage": "vitest run --coverage"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sapphire-sh/sapphire-utils.git"
+	},
+	"author": "sapphire",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/sapphire-sh/sapphire-utils/issues"
+	},
+	"homepage": "https://github.com/sapphire-sh/sapphire-utils#readme",
+	"peerDependencies": {
+		"@eslint/js": ">=9.0.0",
+		"eslint": ">=9.0.0",
+		"eslint-config-prettier": ">=9.0.0",
+		"prettier": ">=3.0.0",
+		"prettier-plugin-organize-imports": ">=4.0.0",
+		"typescript-eslint": ">=8.0.0"
+	},
+	"peerDependenciesMeta": {
+		"@eslint/js": {
+			"optional": true
+		},
+		"eslint": {
+			"optional": true
+		},
+		"eslint-config-prettier": {
+			"optional": true
+		},
+		"typescript-eslint": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.24.0",
+		"@vitest/coverage-v8": "^4.1.1",
+		"eslint": "^9.24.0",
+		"eslint-config-prettier": "^10.1.2",
+		"prettier": "^3.8.1",
+		"prettier-plugin-organize-imports": "^4.3.0",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.29.1",
+		"vitest": "^4.1.1"
+	}
 }