@zintrust/core 0.1.28 → 0.1.29

package/src/cli/utils/spawn.js

@@ -0,0 +1,92 @@
+import { appConfig } from '../../config/app.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { spawn } from '../../node-singletons/child-process.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+const getExitCode = (exitCode, signal) => {
+    if (typeof exitCode === 'number')
+        return exitCode;
+    if (signal === 'SIGINT' || signal === 'SIGTERM')
+        return 0;
+    return 1;
+};
+const resolveLocalBin = (command, cwd) => {
+    // If command is already a path, leave it alone.
+    if (command.includes('/') || command.includes('\\'))
+        return command;
+    const binDir = path.join(cwd, 'node_modules', '.bin');
+    const candidates = process.platform === 'win32'
+        ? [
+            path.join(binDir, `${command}.cmd`),
+            path.join(binDir, `${command}.exe`),
+            path.join(binDir, `${command}.bat`),
+            path.join(binDir, command),
+        ]
+        : [path.join(binDir, command)];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return command;
+};
+export const SpawnUtil = Object.freeze({
+    async spawnAndWait(input) {
+        const cwd = input.cwd ?? process.cwd();
+        const resolvedCommand = resolveLocalBin(input.command, cwd);
+        const child = spawn(resolvedCommand, input.args, {
+            cwd,
+            env: input.env ?? appConfig.getSafeEnv(),
+            stdio: 'inherit',
+        });
+        // In interactive shells, the foreground process group already receives SIGINT
+        // (and often SIGTERM) so forwarding can cause duplicates. `tsx watch` is
+        // especially sensitive here and can print "Previous process hasn't exited yet. Force killing...".
+        const forwardSignals = typeof input.forwardSignals === 'boolean' ? input.forwardSignals : !process.stdin.isTTY;
+        const forwardSignal = (signal) => {
+            try {
+                child.kill(signal);
+            }
+            catch (error) {
+                const wrapped = ErrorFactory.createTryCatchError('Failed to forward signal to child process', error);
+                // Best-effort logging; then rethrow (tests/assertions rely on this behavior).
+                try {
+                    process.stderr.write(`${String(wrapped.message)}\n`);
+                }
+                catch {
+                    // ignore
+                }
+                throw wrapped;
+            }
+        };
+        const onSigint = () => forwardSignal('SIGINT');
+        const onSigterm = () => forwardSignal('SIGTERM');
+        if (forwardSignals) {
+            process.on('SIGINT', onSigint);
+            process.on('SIGTERM', onSigterm);
+        }
+        try {
+            const result = await new Promise((resolve, reject) => {
+                child.once('error', (error) => {
+                    reject(error);
+                });
+                child.once('close', (code, signal) => {
+                    resolve({ exitCode: code, signal });
+                });
+            });
+            return getExitCode(result.exitCode, result.signal);
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'ENOENT') {
+                throw ErrorFactory.createCliError(`Error: '${input.command}' not found on PATH.`);
+            }
+            throw ErrorFactory.createTryCatchError('Failed to spawn child process', error);
+        }
+        finally {
+            if (forwardSignals) {
+                process.off('SIGINT', onSigint);
+                process.off('SIGTERM', onSigterm);
+            }
+        }
+    },
+});

package/src/cli/workers/QueueWorkRunner.d.ts

@@ -0,0 +1,23 @@
+export type QueueWorkKind = 'broadcast' | 'notification';
+export type QueueWorkRunnerOptions = {
+    queueName: string;
+    kind?: QueueWorkKind;
+    driverName?: string;
+    timeoutSeconds?: number;
+    maxItems?: number;
+    /** Max retries after the first attempt (so total attempts = retry + 1) */
+    retry?: number;
+};
+export type QueueWorkRunnerResult = {
+    processed: number;
+    retried: number;
+    dropped: number;
+    notDueRequeued: number;
+    unknown: number;
+};
+export declare const QueueWorkRunner: Readonly<{
+    run(options: QueueWorkRunnerOptions): Promise<QueueWorkRunnerResult>;
+    parseKind(value: unknown): QueueWorkKind;
+}>;
+export default QueueWorkRunner;
+//# sourceMappingURL=QueueWorkRunner.d.ts.map

package/src/cli/workers/QueueWorkRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueueWorkRunner.d.ts","sourceRoot":"","sources":["../../../../src/cli/workers/QueueWorkRunner.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,cAAc,CAAC;AAoBzD,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA0QF,eAAO,MAAM,eAAe;iBACP,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;qBAuCzD,OAAO,GAAG,aAAa;EAUxC,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/cli/workers/QueueWorkRunner.js

@@ -0,0 +1,273 @@
+import { Broadcast } from '../../tools/broadcast/Broadcast.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { queueConfig } from '../../config/queue.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ZintrustLang } from '../../lang/lang.js';
+import { Notification } from '../../tools/notification/Notification.js';
+import { createLockProvider, getLockProvider, registerLockProvider } from '../../tools/queue/LockProvider.js';
+import { Queue, resolveLockPrefix } from '../../tools/queue/Queue.js';
+import { registerQueuesFromRuntimeConfig } from '../../tools/queue/QueueRuntimeRegistration.js';
+const isKind = (value) => value === 'broadcast' || value === 'notification';
+const detectKindFromPayload = (payload) => {
+    if (payload !== null && typeof payload === 'object') {
+        const p = payload;
+        if (isKind(p['type']))
+            return p['type'];
+        if (typeof p['channel'] === 'string' && typeof p['event'] === 'string')
+            return 'broadcast';
+        if (typeof p['recipient'] === 'string' && typeof p['message'] === 'string')
+            return 'notification';
+    }
+    return undefined;
+};
+const normalizeNumber = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return undefined;
+};
+const getTimestamp = (payload) => {
+    return normalizeNumber(payload['timestamp']);
+};
+const getAttempts = (payload) => {
+    const n = normalizeNumber(payload['attempts']);
+    return typeof n === 'number' && n >= 0 ? Math.floor(n) : 0;
+};
+const withAttempts = (payload, attempts) => {
+    return { ...payload, attempts };
+};
+const shouldStop = (startedAtMs, timeoutSeconds) => {
+    if (timeoutSeconds === undefined)
+        return false;
+    const elapsedMs = Date.now() - startedAtMs;
+    return elapsedMs >= timeoutSeconds * 1000;
+};
+const QUEUE_META_KEY = '__zintrustQueueMeta';
+let lockProviderCache = null;
+const getLockProviderForQueue = () => {
+    if (lockProviderCache)
+        return lockProviderCache;
+    const providerName = Env.get('QUEUE_LOCK_PROVIDER', ZintrustLang.REDIS).trim();
+    const prefix = resolveLockPrefix();
+    const defaultTtl = Env.getInt('QUEUE_DEFAULT_DEDUP_TTL', ZintrustLang.ZINTRUST_LOCKS_TTL);
+    const existing = getLockProvider(providerName);
+    if (existing) {
+        lockProviderCache = existing;
+        return existing;
+    }
+    const provider = createLockProvider({
+        type: providerName === ZintrustLang.REDIS ? ZintrustLang.REDIS : ZintrustLang.MEMORY,
+        prefix: prefix.length > 0 ? prefix : ZintrustLang.ZINTRUST_LOCKS_PREFIX,
+        defaultTtl,
+    });
+    registerLockProvider(providerName, provider);
+    // Also register under the literal memory name to ensure callers that expect
+    // a 'memory'-named provider (tests or other runtime code) can find it.
+    if (providerName !== ZintrustLang.MEMORY) {
+        try {
+            registerLockProvider(ZintrustLang.MEMORY, provider);
+        }
+        catch {
+            // Best-effort: ignore registration errors to avoid breaking runtime logic.
+        }
+    }
+    lockProviderCache = provider;
+    return provider;
+};
+const extractQueueMeta = (payload) => {
+    const metaValue = payload[QUEUE_META_KEY];
+    if (metaValue !== undefined && metaValue !== null && typeof metaValue === 'object') {
+        const { [QUEUE_META_KEY]: metaRaw, ...rest } = payload;
+        return { payload: rest, meta: metaRaw };
+    }
+    return { payload, meta: undefined };
+};
+const resolveConditionStatus = (condition) => {
+    const normalized = condition.trim().toLowerCase();
+    if (normalized.includes('failed') || normalized.includes('error'))
+        return 'failed';
+    if (normalized.includes('success') || normalized.includes('completed'))
+        return 'success';
+    // Try to extract explicit comparison like: job.result.status === "completed"
+    const match = new RegExp(/status\s*={1,3}\s*['"]([a-z]+)['"]/).exec(normalized);
+    const capturedValue = match?.[1];
+    if (capturedValue !== null && capturedValue !== undefined && capturedValue.length > 0) {
+        const value = capturedValue;
+        if (value === 'failed' || value === 'error')
+            return 'failed';
+        if (value === 'success' || value === 'completed')
+            return 'success';
+    }
+    return null;
+};
+const shouldReleaseForOutcome = (releaseAfter, outcome) => {
+    if (releaseAfter === 'success')
+        return outcome === 'success';
+    if (releaseAfter === 'failed')
+        return outcome === 'failed';
+    if (typeof releaseAfter === 'string') {
+        const normalized = releaseAfter.toLowerCase();
+        if (normalized.includes('failed') || normalized.includes('error'))
+            return outcome === 'failed';
+        if (normalized.includes('success') || normalized.includes('completed'))
+            return outcome === 'success';
+        const fromCondition = resolveConditionStatus(normalized);
+        return fromCondition !== null && fromCondition === outcome;
+    }
+    if (releaseAfter !== null && releaseAfter !== undefined && typeof releaseAfter === 'object') {
+        const condition = String(releaseAfter.condition ?? '').toLowerCase();
+        const fromCondition = resolveConditionStatus(condition);
+        return fromCondition !== null && fromCondition === outcome;
+    }
+    return false;
+};
+const releaseLockAfterResult = async (meta, outcome) => {
+    if (meta === undefined)
+        return;
+    const deduplicationId = meta.deduplicationId;
+    if (deduplicationId === undefined || deduplicationId === null) {
+        return;
+    }
+    const deduplicationKey = String(deduplicationId).trim();
+    if (deduplicationKey === '')
+        return;
+    const releaseAfter = meta.releaseAfter;
+    if (releaseAfter === undefined || releaseAfter === null || releaseAfter === '')
+        return;
+    if (!shouldReleaseForOutcome(releaseAfter, outcome))
+        return;
+    const provider = getLockProviderForQueue();
+    const doRelease = async () => {
+        const status = await provider.status(deduplicationKey);
+        if (!status.exists)
+            return;
+        await provider.release({
+            key: deduplicationKey,
+            ttl: status.ttl ?? 0,
+            acquired: true,
+            expires: status.expires ?? new Date(),
+        });
+    };
+    const delay = typeof releaseAfter === 'object' && typeof releaseAfter.delay === 'number'
+        ? releaseAfter.delay
+        : 0;
+    if (delay > 0) {
+        const timeoutId = globalThis.setTimeout(() => {
+            void doRelease();
+        }, delay);
+        timeoutId.unref();
+    }
+    else {
+        await doRelease();
+    }
+};
+const processMessage = async (options, msg, maxAttempts, result) => {
+    const payload = msg.payload ?? {};
+    const { payload: payloadWithoutMeta, meta } = extractQueueMeta(payload);
+    const kind = options.kind ?? detectKindFromPayload(payloadWithoutMeta);
+    if (kind === undefined) {
+        Logger.warn('Queue worker: unknown job payload; dropping', {
+            queue: options.queueName,
+            messageId: msg.id,
+            payloadKeys: Object.keys(payload),
+        });
+        result.unknown++;
+        await Queue.ack(options.queueName, msg.id, options.driverName);
+        return 'continue';
+    }
+    const timestamp = getTimestamp(payloadWithoutMeta);
+    if (typeof timestamp === 'number' && timestamp > Date.now()) {
+        // Not due yet: re-enqueue and stop after rotating the head once.
+        const payloadForRequeue = meta
+            ? { ...payloadWithoutMeta, [QUEUE_META_KEY]: meta }
+            : payloadWithoutMeta;
+        await Queue.enqueue(options.queueName, payloadForRequeue, options.driverName);
+        await Queue.ack(options.queueName, msg.id, options.driverName);
+        result.notDueRequeued++;
+        return 'break';
+    }
+    const attempts = getAttempts(payloadWithoutMeta);
+    try {
+        if (kind === 'broadcast') {
+            const job = payloadWithoutMeta;
+            await Broadcast.send(job.channel, job.event, job.data);
+        }
+        else {
+            const job = payloadWithoutMeta;
+            await Notification.send(job.recipient, job.message, job.options ?? {});
+        }
+        await releaseLockAfterResult(meta, 'success');
+        await Queue.ack(options.queueName, msg.id, options.driverName);
+        result.processed++;
+        return 'continue';
+    }
+    catch (error) {
+        const nextAttempts = attempts + 1;
+        const canRetry = nextAttempts < maxAttempts;
+        Logger.error('Queue worker: job failed', {
+            queue: options.queueName,
+            kind,
+            messageId: msg.id,
+            attempts: nextAttempts,
+            maxAttempts,
+            error,
+        });
+        if (canRetry) {
+            const payloadForRetry = meta
+                ? { ...payloadWithoutMeta, [QUEUE_META_KEY]: meta }
+                : payloadWithoutMeta;
+            await Queue.enqueue(options.queueName, withAttempts(payloadForRetry, nextAttempts), options.driverName);
+            result.retried++;
+        }
+        else {
+            await releaseLockAfterResult(meta, 'failed');
+            result.dropped++;
+        }
+        await Queue.ack(options.queueName, msg.id, options.driverName);
+        return 'continue';
+    }
+};
+export const QueueWorkRunner = Object.freeze({
+    async run(options) {
+        registerQueuesFromRuntimeConfig(queueConfig);
+        const startedAtMs = Date.now();
+        const maxItems = typeof options.maxItems === 'number' ? options.maxItems : 1000;
+        const timeoutSeconds = typeof options.timeoutSeconds === 'number' ? options.timeoutSeconds : 10;
+        const maxRetries = typeof options.retry === 'number' ? options.retry : 3;
+        const maxAttempts = Math.max(0, Math.floor(maxRetries)) + 1;
+        const result = {
+            processed: 0,
+            retried: 0,
+            dropped: 0,
+            notDueRequeued: 0,
+            unknown: 0,
+        };
+        /* eslint-disable no-await-in-loop */
+        while (result.processed < maxItems && !shouldStop(startedAtMs, timeoutSeconds)) {
+            const msg = await Queue.dequeue(options.queueName, options.driverName);
+            if (msg === undefined)
+                break;
+            const outcome = await processMessage(options, { id: msg.id, payload: msg.payload ?? {} }, maxAttempts, result);
+            if (outcome === 'break')
+                break;
+        }
+        /* eslint-enable no-await-in-loop */
+        return result;
+    },
+    parseKind(value) {
+        const v = String(value ?? '')
+            .trim()
+            .toLowerCase();
+        if (v === 'broadcast' || v === 'broad')
+            return 'broadcast';
+        if (v === 'notification' || v === 'notify')
+            return 'notification';
+        throw ErrorFactory.createCliError(`Invalid kind '${String(value)}'. Expected 'broadcast' or 'notification'.`);
+    },
+});
+export default QueueWorkRunner;

package/src/collections/Collection.d.ts

@@ -0,0 +1,30 @@
+export type PrimitiveKey = string | number | boolean | null | undefined;
+export type ICollection<T> = Readonly<{
+    all: () => T[];
+    toArray: () => T[];
+    count: () => number;
+    isEmpty: () => boolean;
+    map: <U>(fn: (item: T, index: number) => U) => ICollection<U>;
+    filter: (fn: (item: T, index: number) => boolean) => ICollection<T>;
+    reduce: <U>(fn: (acc: U, item: T, index: number) => U, initial: U) => U;
+    first: (fn?: (item: T, index: number) => boolean) => T | undefined;
+    last: (fn?: (item: T, index: number) => boolean) => T | undefined;
+    pluck: <K extends keyof T>(key: K) => ICollection<T[K]>;
+    where: <K extends keyof T>(key: K, value: T[K]) => ICollection<T>;
+    unique: (keySelector?: (item: T) => PrimitiveKey) => ICollection<T>;
+    sortBy: (keySelector: (item: T) => PrimitiveKey) => ICollection<T>;
+    chunk: (size: number) => ICollection<T[]>;
+    take: (n: number) => ICollection<T>;
+    skip: (n: number) => ICollection<T>;
+    keyBy: <K extends PropertyKey>(keySelector: (item: T) => K) => ReadonlyMap<K, T>;
+    groupBy: <K extends PropertyKey>(keySelector: (item: T) => K) => ReadonlyMap<K, ICollection<T>>;
+    tap: (fn: (items: T[]) => void) => ICollection<T>;
+    [Symbol.iterator]: () => Iterator<T>;
+}>;
+export declare const Collection: Readonly<{
+    from: <T>(items: Iterable<T> | ArrayLike<T> | null | undefined) => ICollection<T>;
+    of: <T>(...items: T[]) => ICollection<T>;
+    isCollection: (value: unknown) => value is ICollection<unknown>;
+}>;
+export declare function collect<T>(items: Iterable<T> | ArrayLike<T> | null | undefined): ICollection<T>;
+//# sourceMappingURL=Collection.d.ts.map

package/src/collections/Collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.ts","sourceRoot":"","sources":["../../../src/collections/Collection.ts"],"names":[],"mappings":"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"}

package/src/collections/Collection.js

@@ -0,0 +1,181 @@
+function normalizeToArray(items) {
+    if (items === null || items === undefined)
+        return [];
+    if (typeof items[Symbol.iterator] === 'function') {
+        return Array.from(items);
+    }
+    return Array.from(items);
+}
+function stableArray(items) {
+    return items.slice();
+}
+function firstMatch(snapshot, fn) {
+    if (!fn)
+        return snapshot[0];
+    for (let i = 0; i < snapshot.length; i += 1) {
+        if (fn(snapshot[i], i))
+            return snapshot[i];
+    }
+    return undefined;
+}
+function lastMatch(snapshot, fn) {
+    if (!fn)
+        return snapshot.at(-1);
+    for (let i = snapshot.length - 1; i >= 0; i -= 1) {
+        if (fn(snapshot[i], i))
+            return snapshot[i];
+    }
+    return undefined;
+}
+function uniqueItems(snapshot, keySelector) {
+    const seen = new Set();
+    const out = [];
+    for (const item of snapshot) {
+        const key = keySelector ? keySelector(item) : item;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+function sortByKey(snapshot, keySelector) {
+    const out = snapshot.slice();
+    out.sort((a, b) => {
+        const ka = keySelector(a);
+        const kb = keySelector(b);
+        const aNil = ka === null || ka === undefined;
+        const bNil = kb === null || kb === undefined;
+        if (aNil && bNil)
+            return 0;
+        if (aNil)
+            return 1;
+        if (bNil)
+            return -1;
+        if (typeof ka === 'number' && typeof kb === 'number')
+            return ka - kb;
+        return String(ka).localeCompare(String(kb));
+    });
+    return out;
+}
+function chunkItems(snapshot, size) {
+    const n = Math.floor(size);
+    if (!Number.isFinite(n) || n <= 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < snapshot.length; i += n) {
+        out.push(snapshot.slice(i, i + n));
+    }
+    return out;
+}
+function keyByItems(snapshot, keySelector) {
+    const out = new Map();
+    for (const item of snapshot) {
+        out.set(keySelector(item), item);
+    }
+    return out;
+}
+function groupByItems(snapshot, keySelector) {
+    const groups = new Map();
+    for (const item of snapshot) {
+        const key = keySelector(item);
+        const bucket = groups.get(key);
+        if (bucket)
+            bucket.push(item);
+        else
+            groups.set(key, [item]);
+    }
+    const out = new Map();
+    for (const [k, bucket] of groups.entries()) {
+        out.set(k, makeCollection(bucket));
+    }
+    return out;
+}
+function makeCollection(items) {
+    const snapshot = stableArray(items);
+    const api = Object.freeze({
+        all: () => snapshot.slice(),
+        toArray: () => snapshot.slice(),
+        count: () => snapshot.length,
+        isEmpty: () => snapshot.length === 0,
+        map: (fn) => {
+            if (typeof fn !== 'function') {
+                throw new TypeError('Map callback must be a function');
+            }
+            return makeCollection(snapshot.map((item, index) => fn(item, index)));
+        },
+        filter: (fn) => {
+            if (typeof fn !== 'function') {
+                throw new TypeError('Filter callback must be a function');
+            }
+            return makeCollection(snapshot.filter((item, index) => fn(item, index)));
+        },
+        reduce: (fn, initial) => {
+            if (typeof fn !== 'function') {
+                throw new TypeError('Reduce callback must be a function');
+            }
+            return snapshot.reduce((accumulator, element, index) => fn(accumulator, element, index), initial);
+        },
+        first: (fn) => {
+            if (fn && typeof fn !== 'function') {
+                throw new TypeError('First callback must be a function');
+            }
+            return firstMatch(snapshot, fn);
+        },
+        last: (fn) => {
+            if (fn && typeof fn !== 'function') {
+                throw new TypeError('Last callback must be a function');
+            }
+            return lastMatch(snapshot, fn);
+        },
+        pluck: (key) => makeCollection(snapshot.map((item) => item[key])),
+        where: (key, value) => makeCollection(snapshot.filter((item) => item[key] === value)),
+        unique: (keySelector) => {
+            if (keySelector && typeof keySelector !== 'function') {
+                throw new TypeError('Unique key selector must be a function');
+            }
+            return makeCollection(uniqueItems(snapshot, keySelector));
+        },
+        sortBy: (keySelector) => {
+            if (typeof keySelector !== 'function') {
+                throw new TypeError('Sort key selector must be a function');
+            }
+            return makeCollection(sortByKey(snapshot, keySelector));
+        },
+        chunk: (size) => makeCollection(chunkItems(snapshot, size)),
+        take: (n) => {
+            const count = Math.max(0, Math.floor(n));
+            return makeCollection(snapshot.slice(0, count));
+        },
+        skip: (n) => {
+            const count = Math.max(0, Math.floor(n));
+            return makeCollection(snapshot.slice(count));
+        },
+        keyBy: (keySelector) => keyByItems(snapshot, keySelector),
+        groupBy: (keySelector) => groupByItems(snapshot, keySelector),
+        tap: (fn) => {
+            fn(snapshot.slice());
+            return makeCollection(snapshot);
+        },
+        [Symbol.iterator]: function* () {
+            for (const item of snapshot)
+                yield item;
+        },
+    });
+    return api;
+}
+export const Collection = Object.freeze({
+    from: (items) => makeCollection(normalizeToArray(items)),
+    of: (...items) => makeCollection(items),
+    isCollection: (value) => {
+        if (value === null || value === undefined)
+            return false;
+        return (typeof value === 'object' &&
+            typeof value.all === 'function' &&
+            typeof value.map === 'function' &&
+            typeof value[Symbol.iterator] === 'function');
+    },
+});
+export function collect(items) {
+    return Collection.from(items);
+}

package/src/collections/index.d.ts

@@ -0,0 +1,3 @@
+export { collect, Collection } from '../collections/Collection';
+export type { ICollection, PrimitiveKey } from '../collections/Collection';
+//# sourceMappingURL=index.d.ts.map

package/src/collections/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/collections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC/D,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC"}

package/src/collections/index.js

@@ -0,0 +1 @@
+export { collect, Collection } from '../collections/Collection.js';

package/src/common/AwsSigV4.d.ts

@@ -0,0 +1,41 @@
+export type AwsSigV4Credentials = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+};
+type CanonicalizedHeaders = {
+    canonicalHeaders: string;
+    signedHeaders: string;
+};
+export declare const AwsSigV4: Readonly<{
+    sha256Hex(data: string | Uint8Array): string;
+    hmacSha256(key: Uint8Array | string, data: string): Uint8Array;
+    toAmzDate(date: Date): {
+        amzDate: string;
+        dateStamp: string;
+    };
+    deriveSigningKey(params: {
+        secretAccessKey: string;
+        dateStamp: string;
+        region: string;
+        service: string;
+    }): Uint8Array;
+    canonicalizeHeaders(headers: Record<string, string>): CanonicalizedHeaders;
+    buildAuthorization(params: {
+        method: string;
+        canonicalUri: string;
+        canonicalQueryString: string;
+        headers: Record<string, string>;
+        payloadHash: string;
+        region: string;
+        service: string;
+        amzDate: string;
+        dateStamp: string;
+        credentials: AwsSigV4Credentials;
+    }): {
+        authorization: string;
+        signedHeaders: string;
+    };
+}>;
+export {};
+//# sourceMappingURL=AwsSigV4.d.ts.map

package/src/common/AwsSigV4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AwsSigV4.d.ts","sourceRoot":"","sources":["../../../src/common/AwsSigV4.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,KAAK,oBAAoB,GAAG;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,QAAQ;oBACH,MAAM,GAAG,UAAU,GAAG,MAAM;oBAI5B,UAAU,GAAG,MAAM,QAAQ,MAAM,GAAG,UAAU;oBAI9C,IAAI,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;6BAapC;QACvB,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB,GAAG,UAAU;iCAOe,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,oBAAoB;+BAY/C;QACzB,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,mBAAmB,CAAC;KAClC,GAAG;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE;EA6CpD,CAAC"}