@uploadista/core 0.0.2 → 0.0.3

package/dist/utils/once.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.js","names":["value: Return | undefined","cached: A | undefined"],"sources":["../../src/utils/once.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { UploadistaError } from \"../errors/uploadista-error\";\n\n// only call a function once\nexport function once<T, A extends unknown[], Return>(\n  fn: (this: T, ...args: A) => Return,\n) {\n  let called = false;\n  let value: Return | undefined;\n  const f = function (this: T, ...args: A): Return {\n    if (called) {\n      if (value) {\n        return value;\n      }\n      throw new Error(\"Function called more than once\");\n    }\n    called = true;\n    value = fn.apply(this, args);\n    return value;\n  };\n  return f;\n}\n\n/**\n * Effect-based once utilities\n */\nexport const OnceEffect = {\n  /**\n   * Creates an Effect-based once function that only executes once\n   * @param effect - The effect to execute only once\n   * @returns Effect that caches the result after first execution\n   */\n  make: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ): Effect.Effect<A, E | UploadistaError, R> => {\n    let cached: A | undefined;\n    let called = false;\n\n    return Effect.gen(function* () {\n      if (called) {\n        if (cached !== undefined) {\n          return cached;\n        }\n        yield* new UploadistaError({\n          code: \"UNKNOWN_ERROR\",\n          status: 500,\n          body: \"Effect called more than once with undefined result\",\n        }).toEffect();\n      }\n\n      called = true;\n      cached = yield* effect;\n      return cached;\n    });\n  },\n\n  /**\n   * Creates a legacy once function wrapper\n   * @param fn - Function to wrap\n   * @returns Once-wrapped function\n   */\n  legacy: once,\n};\n"],"mappings":"kGAIA,SAAgB,EACd,EACA,CACA,IAAI,EAAS,GACTA,EAYJ,OAXU,SAAmB,GAAG,EAAiB,CAC/C,GAAI,EAAQ,CACV,GAAI,EACF,OAAO,EAET,MAAU,MAAM,iCAAiC,CAInD,MAFA,GAAS,GACT,EAAQ,EAAG,MAAM,KAAM,EAAK,CACrB,GAQX,MAAa,EAAa,CAMxB,KACE,GAC6C,CAC7C,IAAIC,EACA,EAAS,GAEb,OAAO,EAAO,IAAI,WAAa,CAC7B,GAAI,EAAQ,CACV,GAAI,IAAW,IAAA,GACb,OAAO,EAET,MAAO,IAAI,EAAgB,CACzB,KAAM,gBACN,OAAQ,IACR,KAAM,qDACP,CAAC,CAAC,UAAU,CAKf,MAFA,GAAS,GACT,EAAS,MAAO,EACT,GACP,EAQJ,OAAQ,EACT"}

package/dist/utils/semaphore.cjs

@@ -1 +0,0 @@
-const e=require(`../semaphore-DVrONiAV.cjs`);exports.SemaphoreEffect=e.SemaphoreEffect,exports.permit=e.permit,exports.semaphore=e.semaphore;

package/dist/utils/semaphore.d.cts

@@ -1,3 +0,0 @@
-import "../uploadista-error-kKlhLRhY.cjs";
-import { Permit, Semaphore, SemaphoreEffect, permit, semaphore } from "../semaphore-BHprIjFI.cjs";
-export { Permit, Semaphore, SemaphoreEffect, permit, semaphore };

package/dist/utils/semaphore.d.ts

@@ -1,78 +0,0 @@
-import { Effect, type Scope } from "effect";
-import type { UploadistaError } from "../errors/uploadista-error";
-type ReleaseCallback = () => Promise<void>;
-/**
- * Creates a permit that must be explicitly released to free up a semaphore slot.
- *
- * Permits are used internally by semaphores to track resource acquisition and release.
- * Each permit represents one available slot in the semaphore's concurrency limit.
- *
- * @param onRelease - Callback function to execute when the permit is released
- * @returns A permit object with a release method
- * @internal
- */
-export declare function permit(onRelease: ReleaseCallback): {
-    release: () => Promise<void>;
-};
-export type Permit = ReturnType<typeof permit>;
-/**
- * Creates a semaphore for controlling concurrent access to resources.
- *
- * A semaphore limits the number of concurrent operations that can access a shared
- * resource. This is useful for:
- * - Limiting parallel file uploads
- * - Controlling database connection pool size
- * - Throttling API requests
- * - Managing concurrent flow node execution
- *
- * When all permits are in use, new acquire() calls will wait until a permit
- * becomes available.
- *
- * @param count - Maximum number of concurrent operations allowed
- * @returns A semaphore object with an acquire method
- *
- * @example
- * ```typescript
- * const uploadSemaphore = semaphore(3); // Max 3 concurrent uploads
- *
- * async function uploadFile(file: File) {
- *   const permit = await uploadSemaphore.acquire();
- *   try {
- *     // Upload file (max 3 concurrent)
- *     await uploadToServer(file);
- *   } finally {
- *     await permit.release();
- *   }
- * }
- *
- * // Process files with concurrency limit
- * await Promise.all(files.map(uploadFile));
- * ```
- */
-export declare function semaphore(count: number): {
-    acquire: () => Promise<Permit>;
-};
-export type Semaphore = ReturnType<typeof semaphore>;
-/**
- * Effect-based semaphore utilities
- */
-export declare const SemaphoreEffect: {
-    /**
-     * Creates an Effect-based semaphore with resource management
-     * @param count - Number of permits available
-     * @returns Effect semaphore with automatic resource cleanup
-     */
-    make: (count: number) => Effect.Effect<{
-        acquire: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | UploadistaError, R>;
-    }, never, Scope.Scope>;
-    /**
-     * Creates a legacy semaphore wrapper
-     * @param count - Number of permits
-     * @returns Legacy semaphore instance
-     */
-    legacy: (count: number) => {
-        acquire: () => Promise<Permit>;
-    };
-};
-export {};
-//# sourceMappingURL=semaphore.d.ts.map

package/dist/utils/semaphore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semaphore.d.ts","sourceRoot":"","sources":["../../src/utils/semaphore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,KAAK,eAAe,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAE3C;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,eAAe;;EAahD;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;AAO/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM;mBAIjB,OAAO,CAAC,MAAM,CAAC;EAgCpC;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;OAIG;kBAEM,MAAM,KACZ,MAAM,CAAC,MAAM,CACd;QACE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,CAAC,CAAC;KAC/C,EACD,KAAK,EACL,KAAK,CAAC,KAAK,CACZ;IAyCD;;;;OAIG;oBACa,MAAM;uBArGF,OAAO,CAAC,MAAM,CAAC;;CAsGpC,CAAC"}

package/dist/utils/semaphore.js

@@ -1,134 +0,0 @@
-import { Effect } from "effect";
-/**
- * Creates a permit that must be explicitly released to free up a semaphore slot.
- *
- * Permits are used internally by semaphores to track resource acquisition and release.
- * Each permit represents one available slot in the semaphore's concurrency limit.
- *
- * @param onRelease - Callback function to execute when the permit is released
- * @returns A permit object with a release method
- * @internal
- */
-export function permit(onRelease) {
-    let isReleased = false;
-    async function release() {
-        if (!isReleased) {
-            isReleased = true;
-            await onRelease();
-        }
-    }
-    return {
-        release,
-    };
-}
-/**
- * Creates a semaphore for controlling concurrent access to resources.
- *
- * A semaphore limits the number of concurrent operations that can access a shared
- * resource. This is useful for:
- * - Limiting parallel file uploads
- * - Controlling database connection pool size
- * - Throttling API requests
- * - Managing concurrent flow node execution
- *
- * When all permits are in use, new acquire() calls will wait until a permit
- * becomes available.
- *
- * @param count - Maximum number of concurrent operations allowed
- * @returns A semaphore object with an acquire method
- *
- * @example
- * ```typescript
- * const uploadSemaphore = semaphore(3); // Max 3 concurrent uploads
- *
- * async function uploadFile(file: File) {
- *   const permit = await uploadSemaphore.acquire();
- *   try {
- *     // Upload file (max 3 concurrent)
- *     await uploadToServer(file);
- *   } finally {
- *     await permit.release();
- *   }
- * }
- *
- * // Process files with concurrency limit
- * await Promise.all(files.map(uploadFile));
- * ```
- */
-export function semaphore(count) {
-    let availablePermits = count;
-    const deferreds = [];
-    function acquire() {
-        if (availablePermits > 0) {
-            return Promise.resolve(createPermit());
-        }
-        const deferred = {};
-        deferred.promise = new Promise((resolve) => {
-            deferred.resolve = resolve;
-        });
-        deferreds.push(deferred);
-        return deferred.promise;
-    }
-    function createPermit() {
-        availablePermits--;
-        return permit(async () => {
-            availablePermits++;
-            if (deferreds.length > 0) {
-                const deferred = deferreds.shift();
-                if (deferred) {
-                    deferred.resolve?.(createPermit());
-                    await deferred.promise;
-                }
-            }
-        });
-    }
-    return {
-        acquire,
-    };
-}
-/**
- * Effect-based semaphore utilities
- */
-export const SemaphoreEffect = {
-    /**
-     * Creates an Effect-based semaphore with resource management
-     * @param count - Number of permits available
-     * @returns Effect semaphore with automatic resource cleanup
-     */
-    make: (count) => Effect.acquireRelease(Effect.sync(() => {
-        let availablePermits = count;
-        const queue = [];
-        const acquire = (effect) => Effect.gen(function* () {
-            // Wait for a permit
-            yield* Effect.async((resume) => {
-                if (availablePermits > 0) {
-                    availablePermits--;
-                    resume(Effect.void);
-                }
-                else {
-                    queue.push((releasePermit) => {
-                        availablePermits--;
-                        resume(Effect.void);
-                    });
-                }
-            });
-            // Execute the effect with cleanup
-            return yield* Effect.ensuring(effect, Effect.sync(() => {
-                availablePermits++;
-                if (queue.length > 0) {
-                    const nextWaiting = queue.shift();
-                    if (nextWaiting) {
-                        nextWaiting(() => { });
-                    }
-                }
-            }));
-        });
-        return { acquire };
-    }), () => Effect.void),
-    /**
-     * Creates a legacy semaphore wrapper
-     * @param count - Number of permits
-     * @returns Legacy semaphore instance
-     */
-    legacy: (count) => semaphore(count),
-};

package/dist/utils/throttle.cjs

@@ -1 +0,0 @@
-const e=require(`../debounce-LZK7yS7Z.cjs`);function t(t,n,{leading:r=!0,trailing:i=!0}={}){return e.debounce(t,n,{leading:r,trailing:i})}const n={legacy:t};exports.ThrottleEffect=n,exports.throttle=t;

package/dist/utils/throttle.d.cts

@@ -1,24 +0,0 @@
-//#region src/utils/throttle.d.ts
-declare function throttle<T, A extends unknown[], Return>(fn: (this: T, ...args: A) => Return, wait: number, {
-  leading,
-  trailing
-}?: {
-  leading?: boolean;
-  trailing?: boolean;
-}): (this: T, ...args: A) => void;
-/**
- * Effect-based throttle utilities
- */
-declare const ThrottleEffect: {
-  /**
-   * Creates a legacy throttle function wrapper
-   * @param fn - Function to throttle
-   * @param wait - Wait time in milliseconds
-   * @param options - Throttle options
-   * @returns Throttled function
-   */
-  legacy: typeof throttle;
-};
-//#endregion
-export { ThrottleEffect, throttle };
-//# sourceMappingURL=throttle.d.cts.map

package/dist/utils/throttle.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.cts","names":[],"sources":["../../src/utils/throttle.ts"],"sourcesContent":[],"mappings":";iBAEgB,oDACH,YAAY,MAAM;;;;EADf,OAAA,CAAA,EAAA,OAAQ;EAAA,QAAA,CAAA,EAAA,OAAA;SACX,EAKsC,CALtC,EAAA,GAAA,IAAA,EAKsC,CALtC,EAAA,GAAA,IAAA;;;;AAIT,cAYS,cAZT,EAAA;;;;AAYJ;;;;iBASC"}

package/dist/utils/throttle.d.ts

@@ -1,18 +0,0 @@
-export declare function throttle<T, A extends unknown[], Return>(fn: (this: T, ...args: A) => Return, wait: number, { leading, trailing, }?: {
-    leading?: boolean;
-    trailing?: boolean;
-}): (this: T, ...args: A) => void;
-/**
- * Effect-based throttle utilities
- */
-export declare const ThrottleEffect: {
-    /**
-     * Creates a legacy throttle function wrapper
-     * @param fn - Function to throttle
-     * @param wait - Wait time in milliseconds
-     * @param options - Throttle options
-     * @returns Throttled function
-     */
-    legacy: typeof throttle;
-};
-//# sourceMappingURL=throttle.d.ts.map

package/dist/utils/throttle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../src/utils/throttle.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAAE,MAAM,EACrD,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM,EACnC,IAAI,EAAE,MAAM,EACZ,EACE,OAAc,EACd,QAAe,GAChB,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,iCAMlD;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;CAEJ,CAAC"}

package/dist/utils/throttle.js

@@ -1,20 +0,0 @@
-import { debounce } from "./debounce.js";
-export function throttle(fn, wait, { leading = true, trailing = true, } = {}) {
-    return debounce(fn, wait, {
-        leading,
-        trailing,
-    });
-}
-/**
- * Effect-based throttle utilities
- */
-export const ThrottleEffect = {
-    /**
-     * Creates a legacy throttle function wrapper
-     * @param fn - Function to throttle
-     * @param wait - Wait time in milliseconds
-     * @param options - Throttle options
-     * @returns Throttled function
-     */
-    legacy: throttle,
-};

package/dist/utils/throttle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.js","names":[],"sources":["../../src/utils/throttle.ts"],"sourcesContent":["import { debounce } from \"./debounce.js\";\n\nexport function throttle<T, A extends unknown[], Return>(\n  fn: (this: T, ...args: A) => Return,\n  wait: number,\n  {\n    leading = true,\n    trailing = true,\n  }: { leading?: boolean; trailing?: boolean } = {},\n) {\n  return debounce(fn, wait, {\n    leading,\n    trailing,\n  });\n}\n\n/**\n * Effect-based throttle utilities\n */\nexport const ThrottleEffect = {\n  /**\n   * Creates a legacy throttle function wrapper\n   * @param fn - Function to throttle\n   * @param wait - Wait time in milliseconds\n   * @param options - Throttle options\n   * @returns Throttled function\n   */\n  legacy: throttle,\n};\n"],"mappings":"mDAEA,SAAgB,EACd,EACA,EACA,CACE,UAAU,GACV,WAAW,IACkC,EAAE,CACjD,CACA,OAAO,EAAS,EAAI,EAAM,CACxB,UACA,WACD,CAAC,CAMJ,MAAa,EAAiB,CAQ5B,OAAQ,EACT"}

package/src/logger/logger.ts

@@ -1,14 +0,0 @@
-export type Logger = {
-  log: (message: string) => void;
-};
-
-export function createLogger(enabled: boolean): Logger {
-  return {
-    log: (message: string) => {
-      if (enabled) {
-        // eslint-disable-next-line no-console
-        console.log(message);
-      }
-    },
-  };
-}