@anvilkit/plugin-asset-manager 0.1.1

package/dist/resolver.js

@@ -0,0 +1,148 @@
+import { AssetResolutionError, AssetValidationError } from "./errors.js";
+import { validateUploadResult } from "./validate-upload-result.js";
+const URL_REJECTION_VALIDATION_CODES = new Set([
+    "EMPTY_UPLOAD_URL",
+    "UNSCHEMED_UPLOAD_URL",
+    "DISALLOWED_UPLOAD_URL_SCHEME",
+    "INVALID_UPLOAD_ID",
+    "PATH_TRAVERSAL_URL",
+    "MIXED_SCRIPT_HOSTNAME"
+]);
+const ASSET_REFERENCE_PREFIX = "asset://";
+const ASSET_PROP_KEYS = new Set([
+    "src",
+    "imageUrl",
+    "imageSrc",
+    "url",
+    "videoUrl",
+    "videoSrc",
+    "fontUrl",
+    "scriptUrl",
+    "styleUrl",
+    "backgroundSrc",
+    "backgroundImage",
+    "poster",
+    "thumbnailSrc"
+]);
+function createIRAssetResolver(options) {
+    return (url)=>{
+        const assetId = parseAssetReference(url);
+        if (null === assetId) return null;
+        const asset = options.registry.get(assetId);
+        if (!asset) throw new AssetResolutionError(assetId, "ASSET_NOT_FOUND");
+        try {
+            const validated = validateUploadResult({
+                id: asset.id,
+                url: asset.url,
+                ...asset.meta ? {
+                    meta: asset.meta
+                } : {}
+            }, {
+                dataUrlAllowlistOptIn: options.dataUrlAllowlistOptIn,
+                allowMixedScriptHostnames: options.allowMixedScriptHostnames
+            });
+            const resolution = {
+                url: validated.url,
+                ...validated.meta ? {
+                    meta: validated.meta
+                } : {}
+            };
+            return resolution;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : `Could not resolve asset "${assetId}"`;
+            const code = error instanceof AssetValidationError && URL_REJECTION_VALIDATION_CODES.has(error.code) ? "ASSET_URL_REJECTED" : "ASSET_VALIDATION_FAILED";
+            throw new AssetResolutionError(assetId, code, message, {
+                cause: error
+            });
+        }
+    };
+}
+async function resolveAssets(ir, resolver) {
+    const rewriteMap = new Map();
+    const assetUrls = collectAssetUrls(ir);
+    for (const url of assetUrls){
+        const resolution = await resolver(url);
+        if (null !== resolution) rewriteMap.set(url, resolution);
+    }
+    const nextIr = {
+        version: ir.version,
+        root: cloneNode(ir.root, rewriteMap),
+        assets: ir.assets.map((asset)=>cloneAsset(asset, rewriteMap)),
+        metadata: {
+            ...ir.metadata
+        }
+    };
+    return deepFreeze(nextIr);
+}
+function collectAssetUrls(ir) {
+    const urls = new Set();
+    for (const asset of ir.assets)if ("" !== asset.url.trim()) urls.add(asset.url);
+    collectNodeAssetUrls(ir.root, urls);
+    return urls;
+}
+function collectNodeAssetUrls(node, urls) {
+    collectValueAssetUrls(node.props, urls);
+    if (node.assets) {
+        for (const asset of node.assets)if ("" !== asset.url.trim()) urls.add(asset.url);
+    }
+    if (node.children) for (const child of node.children)collectNodeAssetUrls(child, urls);
+}
+function collectValueAssetUrls(value, urls, key) {
+    if (Array.isArray(value)) {
+        for (const item of value)collectValueAssetUrls(item, urls);
+        return;
+    }
+    if ("string" == typeof value) {
+        if (void 0 !== key && ASSET_PROP_KEYS.has(key) && "" !== value.trim()) urls.add(value);
+        return;
+    }
+    if (null === value || "object" != typeof value) return;
+    for (const [entryKey, entryValue] of Object.entries(value))collectValueAssetUrls(entryValue, urls, entryKey);
+}
+function parseAssetReference(url) {
+    if (!url.startsWith(ASSET_REFERENCE_PREFIX)) return null;
+    const assetId = url.slice(ASSET_REFERENCE_PREFIX.length).trim();
+    return "" === assetId ? null : assetId;
+}
+function cloneNode(node, rewriteMap) {
+    return {
+        id: node.id,
+        type: node.type,
+        props: cloneValue(node.props, rewriteMap),
+        ...node.children ? {
+            children: node.children.map((child)=>cloneNode(child, rewriteMap))
+        } : {},
+        ...node.assets ? {
+            assets: node.assets.map((asset)=>cloneAsset(asset, rewriteMap))
+        } : {}
+    };
+}
+function cloneAsset(asset, rewriteMap) {
+    const resolution = rewriteMap.get(asset.url);
+    return {
+        id: asset.id,
+        kind: asset.kind,
+        url: resolution?.url ?? asset.url,
+        ...resolution?.meta ?? asset.meta ? {
+            meta: resolution?.meta ?? asset.meta
+        } : {}
+    };
+}
+function cloneValue(value, rewriteMap, key) {
+    if (Array.isArray(value)) return value.map((item)=>cloneValue(item, rewriteMap));
+    if ("string" == typeof value) {
+        if (void 0 !== key && !ASSET_PROP_KEYS.has(key)) return value;
+        return rewriteMap.get(value)?.url ?? value;
+    }
+    if (null === value || "object" != typeof value) return value;
+    const nextValue = {};
+    for (const [entryKey, entryValue] of Object.entries(value))nextValue[entryKey] = cloneValue(entryValue, rewriteMap, entryKey);
+    return nextValue;
+}
+function deepFreeze(value) {
+    if (null === value || "object" != typeof value || Object.isFrozen(value)) return value;
+    Object.freeze(value);
+    for (const entry of Object.values(value))deepFreeze(entry);
+    return value;
+}
+export { createIRAssetResolver, resolveAssets };

package/dist/retry.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RetryableError: ()=>RetryableError,
+    withRetry: ()=>withRetry
+});
+class RetryableError extends Error {
+    retryAfterMs;
+    constructor(message, options){
+        super(message);
+        this.name = "RetryableError";
+        if (options && "cause" in options) this.cause = options.cause;
+        if (options?.retryAfterMs !== void 0) this.retryAfterMs = options.retryAfterMs;
+    }
+}
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 250;
+const DEFAULT_MAX_DELAY_MS = 8000;
+async function withRetry(fn, options = {}) {
+    const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, signal, jitter = Math.random, sleep = defaultSleep } = options;
+    let attempt = 0;
+    while(true){
+        throwIfAborted(signal);
+        try {
+            return await fn(attempt);
+        } catch (error) {
+            throwIfAborted(signal);
+            if (!isRetryable(error)) throw error;
+            if (attempt >= maxRetries) throw error;
+            const delay = computeDelay({
+                attempt,
+                baseDelayMs,
+                maxDelayMs,
+                jitter,
+                retryAfterMs: getRetryAfterMs(error)
+            });
+            await sleep(delay, signal);
+            attempt += 1;
+        }
+    }
+}
+function isRetryable(error) {
+    if (error instanceof RetryableError) return true;
+    return null !== error && "object" == typeof error && "RetryableError" === error.name;
+}
+function getRetryAfterMs(error) {
+    if (null !== error && "object" == typeof error && "number" == typeof error.retryAfterMs) return error.retryAfterMs;
+}
+function computeDelay(input) {
+    if (void 0 !== input.retryAfterMs) return Math.max(0, input.retryAfterMs);
+    const exp = Math.min(input.maxDelayMs, input.baseDelayMs * 2 ** input.attempt);
+    const half = exp / 2;
+    return Math.floor(half + input.jitter() * half);
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) throw makeAbortError(signal);
+}
+function makeAbortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) return reason;
+    if ("u" > typeof DOMException) return new DOMException("Aborted", "AbortError");
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+function defaultSleep(ms, signal) {
+    if (ms <= 0) {
+        throwIfAborted(signal);
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = ()=>{
+            clearTimeout(timer);
+            reject(makeAbortError(signal));
+        };
+        if (signal) {
+            if (signal.aborted) {
+                clearTimeout(timer);
+                reject(makeAbortError(signal));
+                return;
+            }
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+        }
+    });
+}
+exports.RetryableError = __webpack_exports__.RetryableError;
+exports.withRetry = __webpack_exports__.withRetry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RetryableError",
+    "withRetry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/retry.d.cts

@@ -0,0 +1,71 @@
+/**
+ * @file Retry helpers used by network-bound upload adapters.
+ *
+ * `RetryableError` marks a thrown error as transient. `withRetry()`
+ * wraps an async function with exponential backoff plus full-jitter,
+ * abort-aware sleep, and an optional `retryAfterMs` override carried
+ * on the error.
+ *
+ * @experimental Public surface may change before v1.0. Pinned by the
+ * package's `api/api-snapshot.json` once the snapshot script is
+ * extended to scan this entrypoint.
+ */
+/**
+ * Marks an error as transient — `withRetry()` will reschedule the
+ * underlying call rather than rethrow.
+ *
+ * Adapters should throw `RetryableError` for HTTP 5xx, network
+ * failures, and other recoverable conditions; non-retryable errors
+ * (4xx, schema mismatches, abort) should be thrown as plain `Error`
+ * subclasses (typically `AssetValidationError`).
+ *
+ * The optional `retryAfterMs` overrides the next computed delay,
+ * useful when the server returned a `Retry-After` header.
+ */
+export declare class RetryableError extends Error {
+    readonly retryAfterMs?: number;
+    constructor(message: string, options?: {
+        readonly cause?: unknown;
+        readonly retryAfterMs?: number;
+    });
+}
+export interface RetryOptions {
+    /**
+     * Maximum number of retry attempts after the initial call.
+     * `maxRetries: 3` means up to 4 total invocations.
+     *
+     * @default 3
+     */
+    readonly maxRetries?: number;
+    /**
+     * Base delay in milliseconds. The actual delay grows exponentially
+     * (`baseDelayMs * 2^attempt`) and is then jittered.
+     *
+     * @default 250
+     */
+    readonly baseDelayMs?: number;
+    /**
+     * Cap on the computed backoff delay (before jitter).
+     *
+     * @default 8000
+     */
+    readonly maxDelayMs?: number;
+    /** Aborts both the in-flight call and any pending retry sleep. */
+    readonly signal?: AbortSignal;
+    /** Defaults to `Math.random`. Override for deterministic tests. */
+    readonly jitter?: () => number;
+    /** Defaults to a `setTimeout`-based, abort-aware sleep. */
+    readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Run `fn` and retry on `RetryableError` with full-jitter exponential
+ * backoff. Honors `signal` between attempts and during sleep.
+ *
+ * Resolution order on each error:
+ *  1. If the signal is aborted → throw `AbortError` immediately.
+ *  2. If the error is not a `RetryableError` → rethrow.
+ *  3. If retries are exhausted → rethrow the last error.
+ *  4. Otherwise compute backoff, sleep, and try again.
+ */
+export declare function withRetry<T>(fn: (attempt: number) => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.cts.map

package/dist/retry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.cts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;gBAG9B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;CAYvE;AAED,MAAM,WAAW,YAAY;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE;AAMD;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAChC,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACnC,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,CAAC,CAAC,CAmCZ"}

package/dist/retry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @file Retry helpers used by network-bound upload adapters.
+ *
+ * `RetryableError` marks a thrown error as transient. `withRetry()`
+ * wraps an async function with exponential backoff plus full-jitter,
+ * abort-aware sleep, and an optional `retryAfterMs` override carried
+ * on the error.
+ *
+ * @experimental Public surface may change before v1.0. Pinned by the
+ * package's `api/api-snapshot.json` once the snapshot script is
+ * extended to scan this entrypoint.
+ */
+/**
+ * Marks an error as transient — `withRetry()` will reschedule the
+ * underlying call rather than rethrow.
+ *
+ * Adapters should throw `RetryableError` for HTTP 5xx, network
+ * failures, and other recoverable conditions; non-retryable errors
+ * (4xx, schema mismatches, abort) should be thrown as plain `Error`
+ * subclasses (typically `AssetValidationError`).
+ *
+ * The optional `retryAfterMs` overrides the next computed delay,
+ * useful when the server returned a `Retry-After` header.
+ */
+export declare class RetryableError extends Error {
+    readonly retryAfterMs?: number;
+    constructor(message: string, options?: {
+        readonly cause?: unknown;
+        readonly retryAfterMs?: number;
+    });
+}
+export interface RetryOptions {
+    /**
+     * Maximum number of retry attempts after the initial call.
+     * `maxRetries: 3` means up to 4 total invocations.
+     *
+     * @default 3
+     */
+    readonly maxRetries?: number;
+    /**
+     * Base delay in milliseconds. The actual delay grows exponentially
+     * (`baseDelayMs * 2^attempt`) and is then jittered.
+     *
+     * @default 250
+     */
+    readonly baseDelayMs?: number;
+    /**
+     * Cap on the computed backoff delay (before jitter).
+     *
+     * @default 8000
+     */
+    readonly maxDelayMs?: number;
+    /** Aborts both the in-flight call and any pending retry sleep. */
+    readonly signal?: AbortSignal;
+    /** Defaults to `Math.random`. Override for deterministic tests. */
+    readonly jitter?: () => number;
+    /** Defaults to a `setTimeout`-based, abort-aware sleep. */
+    readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Run `fn` and retry on `RetryableError` with full-jitter exponential
+ * backoff. Honors `signal` between attempts and during sleep.
+ *
+ * Resolution order on each error:
+ *  1. If the signal is aborted → throw `AbortError` immediately.
+ *  2. If the error is not a `RetryableError` → rethrow.
+ *  3. If retries are exhausted → rethrow the last error.
+ *  4. Otherwise compute backoff, sleep, and try again.
+ */
+export declare function withRetry<T>(fn: (attempt: number) => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;gBAG9B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;CAYvE;AAED,MAAM,WAAW,YAAY;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE;AAMD;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAChC,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACnC,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,CAAC,CAAC,CAmCZ"}

package/dist/retry.js

@@ -0,0 +1,86 @@
+class RetryableError extends Error {
+    retryAfterMs;
+    constructor(message, options){
+        super(message);
+        this.name = "RetryableError";
+        if (options && "cause" in options) this.cause = options.cause;
+        if (options?.retryAfterMs !== void 0) this.retryAfterMs = options.retryAfterMs;
+    }
+}
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 250;
+const DEFAULT_MAX_DELAY_MS = 8000;
+async function withRetry(fn, options = {}) {
+    const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, signal, jitter = Math.random, sleep = defaultSleep } = options;
+    let attempt = 0;
+    while(true){
+        throwIfAborted(signal);
+        try {
+            return await fn(attempt);
+        } catch (error) {
+            throwIfAborted(signal);
+            if (!isRetryable(error)) throw error;
+            if (attempt >= maxRetries) throw error;
+            const delay = computeDelay({
+                attempt,
+                baseDelayMs,
+                maxDelayMs,
+                jitter,
+                retryAfterMs: getRetryAfterMs(error)
+            });
+            await sleep(delay, signal);
+            attempt += 1;
+        }
+    }
+}
+function isRetryable(error) {
+    if (error instanceof RetryableError) return true;
+    return null !== error && "object" == typeof error && "RetryableError" === error.name;
+}
+function getRetryAfterMs(error) {
+    if (null !== error && "object" == typeof error && "number" == typeof error.retryAfterMs) return error.retryAfterMs;
+}
+function computeDelay(input) {
+    if (void 0 !== input.retryAfterMs) return Math.max(0, input.retryAfterMs);
+    const exp = Math.min(input.maxDelayMs, input.baseDelayMs * 2 ** input.attempt);
+    const half = exp / 2;
+    return Math.floor(half + input.jitter() * half);
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) throw makeAbortError(signal);
+}
+function makeAbortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) return reason;
+    if ("u" > typeof DOMException) return new DOMException("Aborted", "AbortError");
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+function defaultSleep(ms, signal) {
+    if (ms <= 0) {
+        throwIfAborted(signal);
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = ()=>{
+            clearTimeout(timer);
+            reject(makeAbortError(signal));
+        };
+        if (signal) {
+            if (signal.aborted) {
+                clearTimeout(timer);
+                reject(makeAbortError(signal));
+                return;
+            }
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+        }
+    });
+}
+export { RetryableError, withRetry };