@anvilkit/plugin-asset-manager 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ancyloce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,159 @@
+# `@anvilkit/plugin-asset-manager`
+
+Headless asset upload plugin for Anvilkit Studio.
+
+## What it ships
+
+- `createAssetManagerPlugin(options)` for Studio registration and runtime upload handling.
+- `uploadAsset(ctx, file)` for invoking the configured upload adapter and registering the validated result.
+- `getAssetRegistry(ctx)` for reading the plugin runtime registry after `onInit`.
+- `createAssetReference(id)` for producing stable `asset://<id>` references.
+- `createAssetRegistry()` for storing validated asset metadata, with `search`, `setTags`, and pagination.
+- `getRequiredCsp(opts)` for computing the minimum `connect-src` / `img-src` / `media-src` directives the configured adapters need.
+- `./ui` React components for a host-rendered upload button, asset browser (with search + filter chips), command palette, and metadata editor.
+- Reference upload adapters for tests and demos.
+
+## Library management (search, tags, pagination)
+
+`AssetRegistry.search(options)` returns a paginated, filtered slice of the registry:
+
+```ts
+const page = registry.search({
+  query: "hero",          // matches id, name, MIME prefix, and tags (case-insensitive)
+  kinds: ["image"],       // filter by inferred kind (image/video/audio/font/document/other)
+  tags: ["brand"],        // require all listed tags (AND semantics)
+  limit: 20,
+  cursor: undefined,      // opaque; pass `page.nextCursor` to advance
+});
+```
+
+Tags are auto-derived on every upload (kind + up to two filename tokens, capped at 3) and can be edited via `registry.setTags(id, tags)` or the `MetadataPanel` UI. Host-supplied `UploadResult.tags` are preserved verbatim.
+
+`StudioAssetSource.listPaginated(query)` is the sidebar-facing pagination contract — remote sources can implement it to push search and pagination to the server. Sidebar consumers fall back to `list()` when omitted.
+
+`StudioAssetSource.subscribeUploads(listener)` is a streaming channel that fans `progress` / `done` / `error` envelopes out to every subscriber alongside the inline upload listener.
+
+## Trust model
+
+`UploadAdapter.url` is treated as untrusted input. Every adapter response is validated through `validateUploadResult()` before it reaches the registry or IR-shaped data.
+
+The default scheme set is **always** `http`, `https`, and `blob`. `javascript:` and `vbscript:` are hard-blocked under all configurations. `data:` is **off by default** in v1.0 — enable it explicitly per plugin instance:
+
+```ts
+createAssetManagerPlugin({
+  uploader: dataUrlUploader(),
+  dataUrlAllowlistOptIn: true,
+});
+```
+
+Two further hardening checks run at validation time:
+
+- **Path traversal.** `../` and percent-encoded variants (`%2e%2e/`, `%2e%2e%2f`) are rejected on `http`/`https`/`blob` URLs.
+- **IDN homoglyph.** Hostnames mixing Latin with a visually confusable script (Cyrillic or Greek) are rejected. Single-script IDN hosts such as `münchen.de`, `日本.jp`, or `россия.рф` are always allowed. Hosts that legitimately need this combination can pass `allowMixedScriptHostnames: true`.
+
+### Migration from `urlAllowlist` (alpha → 1.0)
+
+The alpha-era `urlAllowlist?: readonly string[]` field is removed in v1.0. Replace any existing usage with the typed flags:
+
+| Alpha                                          | v1.0                                |
+| ---------------------------------------------- | ----------------------------------- |
+| `urlAllowlist: ["http", "https", "blob"]`      | _(default — drop the field)_        |
+| `urlAllowlist: ["http", "https", "blob", "data"]` | `dataUrlAllowlistOptIn: true`    |
+| `urlAllowlist: ["http", "https", "blob", "ftp"]`  | _not supported — write a custom resolver wrapper_ |
+
+If your host needs an exotic scheme (`s3:`, `ipfs:`, `gs:`), wrap `validateUploadResult` and pass the result to `registry.register` directly. The rationale for dropping arbitrary scheme strings: every scheme allowed at the boundary needs its own CSP / sanitization story — typed flags force that decision to be explicit.
+
+## Content Security Policy
+
+`getRequiredCsp(options)` computes the minimum CSP directives the configured adapters need. Call it once at boot and merge the result into your existing CSP builder:
+
+```ts
+import { getRequiredCsp } from "@anvilkit/plugin-asset-manager";
+
+const csp = getRequiredCsp({
+  dataUrl: true,
+  s3: { presignEndpoint: "https://uploads.example.com/sign" },
+});
+// csp.connectSrc → ["https://uploads.example.com"]
+// csp.imgSrc     → ["data:", "https://uploads.example.com"]
+// csp.mediaSrc   → ["data:", "https://uploads.example.com"]
+```
+
+| Adapter                | `connect-src`                | `img-src`                    | `media-src`                  |
+| ---------------------- | ---------------------------- | ---------------------------- | ---------------------------- |
+| `dataUrlUploader`      | _(none)_                     | `data:`                      | `data:`                      |
+| `inMemoryUploader`     | _(none)_                     | `blob:`                      | `blob:`                      |
+| `s3PresignedAdapter`   | presign origin + `publicHost`| `publicHost` ?? presign      | `publicHost` ?? presign      |
+
+If your `publicUrl` returned by the presign service points at a different origin than the presign endpoint itself, pass `s3: { presignEndpoint, publicHost }` so the advisor can split the directives correctly.
+
+## Entry points
+
+- `@anvilkit/plugin-asset-manager` — headless runtime, validation, adapters, errors, CSP advisor.
+- `@anvilkit/plugin-asset-manager/ui` — React UI components.
+- `@anvilkit/plugin-asset-manager/retry` — generic `RetryableError` + `withRetry()`.
+- `@anvilkit/plugin-asset-manager/adapters/s3` — `s3PresignedAdapter`.
+- `@anvilkit/plugin-asset-manager/testing` — fixtures for downstream plugin tests.
+
+## Batch upload behaviour
+
+`StudioAssetSource.upload(files)` runs up to `MAX_CONCURRENT_UPLOADS` (default 3) uploads in parallel. Per-file failures surface via the listener as `error` envelopes; the returned promise resolves with the successful subset and **does not throw**. Hosts that need fail-fast semantics can pass `maxConcurrentUploads: 1`.
+
+`AbortError`s thrown from the adapter abort the whole batch — pending files are not scheduled.
+
+## S3 presigned adapter
+
+```ts
+import { s3PresignedAdapter } from "@anvilkit/plugin-asset-manager/adapters/s3";
+import { createAssetManagerPlugin } from "@anvilkit/plugin-asset-manager";
+
+createAssetManagerPlugin({
+  uploader: s3PresignedAdapter({
+    presignEndpoint: "/api/sign",
+    retry: { maxRetries: 3 },
+  }),
+});
+```
+
+The adapter POSTs `{ name, type, size }` to `presignEndpoint`, expects `{ url, publicUrl?, headers?, id? }` back, then PUTs the file to `url`. Both phases retry on 5xx and network errors with exponential backoff. 4xx responses fail without retry.
+
+If the host endpoint is **not** S3-compatible (e.g. a custom uploader without overwrite semantics), pass `retry: { maxRetries: 0 }` to disable retry and avoid the small chance of a duplicate upload.
+
+The adapter never logs file contents — only `name`, `size`, and `mimeType`.
+
+## Production checklist
+
+Before mounting in a real Studio host:
+
+1. **Pick the right adapter.** `dataUrlUploader` is dev-only (size cap, in-memory). `s3PresignedAdapter` is the production default; wire it to your presign endpoint and set `retry: { maxRetries: 3 }`.
+2. **Set the trust flags explicitly.** Decide whether your host needs `dataUrlAllowlistOptIn: true` (only if your editor flow embeds `data:` URLs end-to-end). Leave `allowMixedScriptHostnames` off unless you have a documented business need.
+3. **Wire CSP.** Call `getRequiredCsp(...)` and merge the result into your `connect-src` / `img-src` / `media-src` builder. Re-run when you add or remove an adapter.
+4. **Choose a persistence story.** The plugin keeps state in-memory per Studio mount. If you need cross-session asset reuse, the host stores `publicUrl`s server-side and re-seeds the registry on boot via `registry.register`.
+5. **Decide on monitoring.** Subscribe to the `asset-manager:error` event bus envelopes (`code`, `message`) for upload failures, and log `AssetResolutionError.code` from your export pipeline so `ASSET_NOT_FOUND` / `ASSET_URL_REJECTED` / `ASSET_VALIDATION_FAILED` get separate alerts.
+6. **Lock down the bundle.** Consult `.size-limit.json` — the headless entry stays under 6 KB gzip; the UI subpath stays under 12 KB. CI gates both.
+
+## Error codes
+
+`AssetValidationError.code` (raised by upload + validation):
+
+| Code                           | Source                          |
+| ------------------------------ | ------------------------------- |
+| `FILE_TOO_LARGE`               | `validateSelectedFile`          |
+| `UNSUPPORTED_MIME_TYPE`        | `validateSelectedFile`          |
+| `INVALID_UPLOAD_ID`            | `validateUploadResult`          |
+| `EMPTY_UPLOAD_URL`             | `validateUploadResult`          |
+| `UNSCHEMED_UPLOAD_URL`         | `validateUploadResult`          |
+| `DISALLOWED_UPLOAD_URL_SCHEME` | `validateUploadResult`          |
+| `PATH_TRAVERSAL_URL`           | `validateUploadResult`          |
+| `MIXED_SCRIPT_HOSTNAME`        | `validateUploadResult`          |
+| `DATA_URL_FILE_TOO_LARGE`      | `dataUrlUploader`               |
+| `DATA_URL_READ_FAILED`         | `dataUrlUploader`               |
+| `UPLOAD_FAILED`                | `uploadAsset` fallback wrap     |
+
+`AssetResolutionError.code` (raised by `IRAssetResolver`):
+
+| Code                       | Meaning                                            |
+| -------------------------- | -------------------------------------------------- |
+| `ASSET_NOT_FOUND`          | The registry has no entry for the asset id.       |
+| `ASSET_URL_REJECTED`       | The stored URL failed the allowlist or trust gate. |
+| `ASSET_VALIDATION_FAILED`  | Catch-all for unexpected resolver failures.        |

package/dist/adapters/data-url.cjs

@@ -0,0 +1,78 @@
+"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__, {
+    dataUrlUploader: ()=>dataUrlUploader
+});
+const external_errors_cjs_namespaceObject = require("../errors.cjs");
+const external_extract_image_dimensions_cjs_namespaceObject = require("./extract-image-dimensions.cjs");
+const DEFAULT_MAX_BYTES = 1048576;
+function dataUrlUploader(options = {}) {
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    let counter = 0;
+    return async (file)=>{
+        if (file.size > maxBytes) throw new external_errors_cjs_namespaceObject.AssetValidationError("DATA_URL_FILE_TOO_LARGE", `File size ${file.size} bytes exceeds the data URL adapter limit of ${maxBytes} bytes.`);
+        counter += 1;
+        const url = await readAsDataUrl(file);
+        const dimensions = await (0, external_extract_image_dimensions_cjs_namespaceObject.extractImageDimensions)(url, file.type);
+        const result = {
+            id: `asset-${counter}`,
+            url,
+            meta: {
+                size: file.size,
+                ...file.type ? {
+                    mimeType: file.type
+                } : {},
+                ...dimensions ? {
+                    width: dimensions.width,
+                    height: dimensions.height
+                } : {}
+            }
+        };
+        return result;
+    };
+}
+function readAsDataUrl(file) {
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onerror = ()=>{
+            reject(new external_errors_cjs_namespaceObject.AssetValidationError("DATA_URL_READ_FAILED", "Failed to read file as a data URL.", {
+                cause: reader.error
+            }));
+        };
+        reader.onload = ()=>{
+            if ("string" != typeof reader.result) return void reject(new external_errors_cjs_namespaceObject.AssetValidationError("DATA_URL_READ_FAILED", "FileReader did not produce a string data URL."));
+            resolve(reader.result);
+        };
+        reader.readAsDataURL(file);
+    });
+}
+exports.dataUrlUploader = __webpack_exports__.dataUrlUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dataUrlUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/adapters/data-url.d.cts

@@ -0,0 +1,6 @@
+import type { UploadAdapter } from "../types.js";
+export interface DataUrlUploaderOptions {
+    readonly maxBytes?: number;
+}
+export declare function dataUrlUploader(options?: DataUrlUploaderOptions): UploadAdapter;
+//# sourceMappingURL=data-url.d.cts.map

package/dist/adapters/data-url.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-url.d.cts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AAG/D,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA6Bf"}

package/dist/adapters/data-url.d.ts

@@ -0,0 +1,6 @@
+import type { UploadAdapter } from "../types.js";
+export interface DataUrlUploaderOptions {
+    readonly maxBytes?: number;
+}
+export declare function dataUrlUploader(options?: DataUrlUploaderOptions): UploadAdapter;
+//# sourceMappingURL=data-url.d.ts.map

package/dist/adapters/data-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-url.d.ts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AAG/D,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA6Bf"}

package/dist/adapters/data-url.js

@@ -0,0 +1,44 @@
+import { AssetValidationError } from "../errors.js";
+import { extractImageDimensions } from "./extract-image-dimensions.js";
+const DEFAULT_MAX_BYTES = 1048576;
+function dataUrlUploader(options = {}) {
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    let counter = 0;
+    return async (file)=>{
+        if (file.size > maxBytes) throw new AssetValidationError("DATA_URL_FILE_TOO_LARGE", `File size ${file.size} bytes exceeds the data URL adapter limit of ${maxBytes} bytes.`);
+        counter += 1;
+        const url = await readAsDataUrl(file);
+        const dimensions = await extractImageDimensions(url, file.type);
+        const result = {
+            id: `asset-${counter}`,
+            url,
+            meta: {
+                size: file.size,
+                ...file.type ? {
+                    mimeType: file.type
+                } : {},
+                ...dimensions ? {
+                    width: dimensions.width,
+                    height: dimensions.height
+                } : {}
+            }
+        };
+        return result;
+    };
+}
+function readAsDataUrl(file) {
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onerror = ()=>{
+            reject(new AssetValidationError("DATA_URL_READ_FAILED", "Failed to read file as a data URL.", {
+                cause: reader.error
+            }));
+        };
+        reader.onload = ()=>{
+            if ("string" != typeof reader.result) return void reject(new AssetValidationError("DATA_URL_READ_FAILED", "FileReader did not produce a string data URL."));
+            resolve(reader.result);
+        };
+        reader.readAsDataURL(file);
+    });
+}
+export { dataUrlUploader };

package/dist/adapters/extract-image-dimensions.cjs

@@ -0,0 +1,69 @@
+"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__, {
+    extractImageDimensions: ()=>extractImageDimensions
+});
+const DEFAULT_TIMEOUT_MS = 3000;
+async function extractImageDimensions(url, mimeType, options = {}) {
+    if (!mimeType || !mimeType.startsWith("image/")) return;
+    if ("u" < typeof Image) return;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve)=>{
+        let settled = false;
+        const image = new Image();
+        const settle = (value)=>{
+            if (settled) return;
+            settled = true;
+            image.onload = null;
+            image.onerror = null;
+            if (void 0 !== timer) clearTimeout(timer);
+            resolve(value);
+        };
+        image.onload = ()=>{
+            const width = Math.round(image.naturalWidth);
+            const height = Math.round(image.naturalHeight);
+            if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1) return void settle(void 0);
+            settle({
+                width,
+                height
+            });
+        };
+        image.onerror = ()=>{
+            settle(void 0);
+        };
+        const timer = timeoutMs > 0 ? setTimeout(()=>{
+            settle(void 0);
+        }, timeoutMs) : void 0;
+        image.src = url;
+    });
+}
+exports.extractImageDimensions = __webpack_exports__.extractImageDimensions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractImageDimensions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/adapters/extract-image-dimensions.d.cts

@@ -0,0 +1,21 @@
+/**
+ * @file Best-effort image dimension extraction for reference adapters.
+ *
+ * Decodes an image URL via the `Image` constructor and resolves the
+ * `naturalWidth` / `naturalHeight`. Returns `undefined` when the runtime
+ * has no `Image` global (SSR), the MIME type is not `image/*`, the decode
+ * fails, or the timeout elapses — adapters must succeed regardless.
+ *
+ * The resolved values are integers ≥ 1; degenerate sizes (0, NaN) are
+ * filtered out so consumers can rely on the shape.
+ */
+export interface ExtractImageDimensionsOptions {
+    /** Abort decode after this many ms. Default 3000. */
+    readonly timeoutMs?: number;
+}
+export interface ImageDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+export declare function extractImageDimensions(url: string, mimeType: string | undefined, options?: ExtractImageDimensionsOptions): Promise<ImageDimensions | undefined>;
+//# sourceMappingURL=extract-image-dimensions.d.cts.map

package/dist/adapters/extract-image-dimensions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-image-dimensions.d.cts","sourceRoot":"","sources":["../../src/adapters/extract-image-dimensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,6BAA6B;IAC7C,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAID,wBAAsB,sBAAsB,CAC3C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,GAAE,6BAAkC,GACzC,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAsDtC"}

package/dist/adapters/extract-image-dimensions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Best-effort image dimension extraction for reference adapters.
+ *
+ * Decodes an image URL via the `Image` constructor and resolves the
+ * `naturalWidth` / `naturalHeight`. Returns `undefined` when the runtime
+ * has no `Image` global (SSR), the MIME type is not `image/*`, the decode
+ * fails, or the timeout elapses — adapters must succeed regardless.
+ *
+ * The resolved values are integers ≥ 1; degenerate sizes (0, NaN) are
+ * filtered out so consumers can rely on the shape.
+ */
+export interface ExtractImageDimensionsOptions {
+    /** Abort decode after this many ms. Default 3000. */
+    readonly timeoutMs?: number;
+}
+export interface ImageDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+export declare function extractImageDimensions(url: string, mimeType: string | undefined, options?: ExtractImageDimensionsOptions): Promise<ImageDimensions | undefined>;
+//# sourceMappingURL=extract-image-dimensions.d.ts.map

package/dist/adapters/extract-image-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-image-dimensions.d.ts","sourceRoot":"","sources":["../../src/adapters/extract-image-dimensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,6BAA6B;IAC7C,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAID,wBAAsB,sBAAsB,CAC3C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,GAAE,6BAAkC,GACzC,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAsDtC"}

package/dist/adapters/extract-image-dimensions.js

@@ -0,0 +1,35 @@
+const DEFAULT_TIMEOUT_MS = 3000;
+async function extractImageDimensions(url, mimeType, options = {}) {
+    if (!mimeType || !mimeType.startsWith("image/")) return;
+    if ("u" < typeof Image) return;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve)=>{
+        let settled = false;
+        const image = new Image();
+        const settle = (value)=>{
+            if (settled) return;
+            settled = true;
+            image.onload = null;
+            image.onerror = null;
+            if (void 0 !== timer) clearTimeout(timer);
+            resolve(value);
+        };
+        image.onload = ()=>{
+            const width = Math.round(image.naturalWidth);
+            const height = Math.round(image.naturalHeight);
+            if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1) return void settle(void 0);
+            settle({
+                width,
+                height
+            });
+        };
+        image.onerror = ()=>{
+            settle(void 0);
+        };
+        const timer = timeoutMs > 0 ? setTimeout(()=>{
+            settle(void 0);
+        }, timeoutMs) : void 0;
+        image.src = url;
+    });
+}
+export { extractImageDimensions };

package/dist/adapters/in-memory.cjs

@@ -0,0 +1,62 @@
+"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__, {
+    inMemoryUploader: ()=>inMemoryUploader
+});
+const external_extract_image_dimensions_cjs_namespaceObject = require("./extract-image-dimensions.cjs");
+function inMemoryUploader() {
+    const filesById = new Map();
+    let counter = 0;
+    return async (file)=>{
+        counter += 1;
+        const id = `asset-${counter}`;
+        filesById.set(id, file);
+        const url = "function" == typeof URL.createObjectURL ? URL.createObjectURL(file) : `blob:asset-manager/${id}`;
+        const dimensions = await (0, external_extract_image_dimensions_cjs_namespaceObject.extractImageDimensions)(url, file.type);
+        const result = {
+            id,
+            url,
+            meta: {
+                size: file.size,
+                ...file.type ? {
+                    mimeType: file.type
+                } : {},
+                ...dimensions ? {
+                    width: dimensions.width,
+                    height: dimensions.height
+                } : {}
+            }
+        };
+        return result;
+    };
+}
+exports.inMemoryUploader = __webpack_exports__.inMemoryUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "inMemoryUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/adapters/in-memory.d.cts

@@ -0,0 +1,3 @@
+import type { UploadAdapter } from "../types.js";
+export declare function inMemoryUploader(): UploadAdapter;
+//# sourceMappingURL=in-memory.d.cts.map

package/dist/adapters/in-memory.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.cts","sourceRoot":"","sources":["../../src/adapters/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AAG/D,wBAAgB,gBAAgB,IAAI,aAAa,CA8BhD"}

package/dist/adapters/in-memory.d.ts

@@ -0,0 +1,3 @@
+import type { UploadAdapter } from "../types.js";
+export declare function inMemoryUploader(): UploadAdapter;
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/adapters/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../src/adapters/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AAG/D,wBAAgB,gBAAgB,IAAI,aAAa,CA8BhD"}

package/dist/adapters/in-memory.js

@@ -0,0 +1,28 @@
+import { extractImageDimensions } from "./extract-image-dimensions.js";
+function inMemoryUploader() {
+    const filesById = new Map();
+    let counter = 0;
+    return async (file)=>{
+        counter += 1;
+        const id = `asset-${counter}`;
+        filesById.set(id, file);
+        const url = "function" == typeof URL.createObjectURL ? URL.createObjectURL(file) : `blob:asset-manager/${id}`;
+        const dimensions = await extractImageDimensions(url, file.type);
+        const result = {
+            id,
+            url,
+            meta: {
+                size: file.size,
+                ...file.type ? {
+                    mimeType: file.type
+                } : {},
+                ...dimensions ? {
+                    width: dimensions.width,
+                    height: dimensions.height
+                } : {}
+            }
+        };
+        return result;
+    };
+}
+export { inMemoryUploader };