@anvilkit/plugin-asset-manager 0.1.1

package/dist/plugin.cjs

@@ -0,0 +1,258 @@
+"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__, {
+    uploadAsset: ()=>uploadAsset,
+    validateSelectedFile: ()=>validateSelectedFile,
+    createAssetManagerPlugin: ()=>createAssetManagerPlugin,
+    getAssetRegistry: ()=>getAssetRegistry,
+    createAssetReference: ()=>external_asset_reference_cjs_namespaceObject.createAssetReference
+});
+const external_asset_reference_cjs_namespaceObject = require("./asset-reference.cjs");
+const external_errors_cjs_namespaceObject = require("./errors.cjs");
+const external_header_action_cjs_namespaceObject = require("./header-action.cjs");
+const external_infer_kind_cjs_namespaceObject = require("./infer-kind.cjs");
+const external_registry_cjs_namespaceObject = require("./registry.cjs");
+const external_resolver_cjs_namespaceObject = require("./resolver.cjs");
+const external_studio_asset_source_cjs_namespaceObject = require("./studio-asset-source.cjs");
+const external_validate_upload_result_cjs_namespaceObject = require("./validate-upload-result.cjs");
+const META = {
+    id: "anvilkit-plugin-asset-manager",
+    name: "Asset Manager",
+    version: "1.0.0",
+    coreVersion: "^0.1.0-alpha",
+    description: "Headless asset upload plugin with host-provided persistence and a separate React UI subpath."
+};
+const stateByToken = new WeakMap();
+const tokenByContext = new WeakMap();
+function createAssetManagerPlugin(options) {
+    const token = {};
+    const registry = (0, external_registry_cjs_namespaceObject.createAssetRegistry)();
+    const normalizedOptions = normalizeOptions(options);
+    const assetResolver = (0, external_resolver_cjs_namespaceObject.createIRAssetResolver)({
+        registry,
+        dataUrlAllowlistOptIn: normalizedOptions.dataUrlAllowlistOptIn,
+        allowMixedScriptHostnames: normalizedOptions.allowMixedScriptHostnames
+    });
+    return {
+        meta: META,
+        register (_ctx) {
+            const registration = {
+                meta: META,
+                headerActions: [
+                    external_header_action_cjs_namespaceObject.uploadAssetAction
+                ],
+                hooks: {
+                    onInit (initCtx) {
+                        const cleanups = [];
+                        stateByToken.set(token, {
+                            options: normalizedOptions,
+                            registry,
+                            cleanups
+                        });
+                        tokenByContext.set(initCtx, token);
+                        initCtx.registerAssetResolver(assetResolver);
+                        const studioAssetSource = (0, external_studio_asset_source_cjs_namespaceObject.createStudioAssetSource)({
+                            registry,
+                            upload: (file)=>uploadAsset(initCtx, file),
+                            ...normalizedOptions.getThumbnail ? {
+                                getThumbnail: normalizedOptions.getThumbnail
+                            } : {}
+                        });
+                        const unregisterAssetSource = initCtx.registerAssetSource?.(studioAssetSource);
+                        if (void 0 !== unregisterAssetSource) cleanups.push(unregisterAssetSource);
+                    },
+                    onDestroy (destroyCtx) {
+                        const state = stateByToken.get(token);
+                        if (void 0 !== state) for (const cleanup of state.cleanups)cleanup();
+                        tokenByContext.delete(destroyCtx);
+                        stateByToken.delete(token);
+                    }
+                }
+            };
+            return registration;
+        }
+    };
+}
+function getAssetRegistry(ctx) {
+    const token = tokenByContext.get(ctx);
+    return token ? stateByToken.get(token)?.registry : void 0;
+}
+async function uploadAsset(ctx, file) {
+    const state = getRuntimeState(ctx);
+    const { options, registry } = state;
+    try {
+        validateSelectedFile(file, options);
+        const uploadResult = await options.uploader(file);
+        const validated = (0, external_validate_upload_result_cjs_namespaceObject.validateUploadResult)(mergeUploadMeta(uploadResult, file), options);
+        const tagged = withDerivedTags(validated, file);
+        const stored = registry.register(tagged);
+        dispatchAssetReference(ctx, stored);
+        ctx.emit("asset-manager:uploaded", {
+            asset: stored,
+            reference: (0, external_asset_reference_cjs_namespaceObject.createAssetReference)(stored.id)
+        });
+        return stored;
+    } catch (error) {
+        const normalizedError = error instanceof external_errors_cjs_namespaceObject.AssetValidationError ? error : new external_errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", error instanceof Error ? error.message : String(error), {
+            cause: error
+        });
+        ctx.emit("asset-manager:error", {
+            code: normalizedError.code,
+            message: normalizedError.message
+        });
+        ctx.log("error", normalizedError.message, {
+            code: normalizedError.code
+        });
+        throw normalizedError;
+    }
+}
+function validateSelectedFile(file, options) {
+    if (void 0 !== options.maxFileSize && file.size > options.maxFileSize) throw new external_errors_cjs_namespaceObject.AssetValidationError("FILE_TOO_LARGE", `File size ${file.size} bytes exceeds the configured maxFileSize of ${options.maxFileSize} bytes.`);
+    if (options.acceptedMimeTypes && options.acceptedMimeTypes.length > 0 && !mimeTypeMatches(file.type, options.acceptedMimeTypes)) {
+        const mimeType = file.type || "unknown";
+        throw new external_errors_cjs_namespaceObject.AssetValidationError("UNSUPPORTED_MIME_TYPE", `File MIME type "${mimeType}" is not in acceptedMimeTypes.`);
+    }
+}
+function getRuntimeState(ctx) {
+    const token = tokenByContext.get(ctx);
+    const state = token ? stateByToken.get(token) : void 0;
+    if (!state) throw new Error("createAssetManagerPlugin: uploadAsset called before the plugin runtime was initialized.");
+    return state;
+}
+function normalizeOptions(options) {
+    return {
+        ...options,
+        ...options.acceptedMimeTypes ? {
+            acceptedMimeTypes: Object.freeze([
+                ...options.acceptedMimeTypes
+            ])
+        } : {}
+    };
+}
+function withDerivedTags(asset, file) {
+    if (void 0 !== asset.tags && asset.tags.length > 0) return asset;
+    const tags = new Set();
+    const kind = (0, external_infer_kind_cjs_namespaceObject.inferAssetKind)(asset);
+    if ("other" !== kind) tags.add(kind);
+    for (const token of filenameTokens(file.name)){
+        if (tags.size >= 3) break;
+        tags.add(token);
+    }
+    if (0 === tags.size) return asset;
+    return {
+        ...asset,
+        tags: Object.freeze([
+            ...tags
+        ])
+    };
+}
+function filenameTokens(name) {
+    const stem = name.replace(/\.[^./\\]+$/, "");
+    const tokens = stem.toLowerCase().split(/[^a-z0-9]+/).filter((token)=>token.length >= 2 && !/^\d+$/.test(token));
+    return tokens.slice(0, 2);
+}
+function mergeUploadMeta(result, file) {
+    const meta = {
+        size: file.size,
+        ...file.type ? {
+            mimeType: file.type
+        } : {},
+        ...result.meta ?? {}
+    };
+    return {
+        ...result,
+        ...void 0 === result.name && file.name ? {
+            name: file.name
+        } : {},
+        meta
+    };
+}
+function mimeTypeMatches(input, acceptedMimeTypes) {
+    if ("" === input) return false;
+    return acceptedMimeTypes.some((accepted)=>{
+        if (accepted.endsWith("/*")) {
+            const prefix = accepted.slice(0, accepted.length - 1);
+            return input.startsWith(prefix);
+        }
+        return input === accepted;
+    });
+}
+function dispatchAssetReference(ctx, asset) {
+    const currentData = ctx.getData();
+    const currentAssetsRaw = Array.isArray(currentData.assets) ? currentData.assets : [];
+    const assetEntry = toIRAsset(asset);
+    const nextAssets = [];
+    let replaced = false;
+    for (const entry of currentAssetsRaw)if (isRecord(entry) && "string" == typeof entry.id && entry.id === asset.id) {
+        nextAssets.push(assetEntry);
+        replaced = true;
+    } else nextAssets.push(entry);
+    if (!replaced) nextAssets.push(assetEntry);
+    const nextData = {
+        ...currentData,
+        assets: nextAssets
+    };
+    ctx.getPuckApi().dispatch({
+        type: "setData",
+        data: nextData
+    });
+}
+function toIRAsset(asset) {
+    return {
+        id: asset.id,
+        kind: inferIRAssetKind(asset.meta?.mimeType, asset.url),
+        url: (0, external_asset_reference_cjs_namespaceObject.createAssetReference)(asset.id),
+        ...asset.meta ? {
+            meta: asset.meta
+        } : {}
+    };
+}
+function inferIRAssetKind(mimeType, url) {
+    if (mimeType?.startsWith("image/")) return "image";
+    if (mimeType?.startsWith("video/")) return "video";
+    if (mimeType?.startsWith("font/") || /\.(?:woff2?|ttf|otf)(?:$|[?#])/i.test(url)) return "font";
+    if ("text/css" === mimeType) return "style";
+    if ("application/javascript" === mimeType || "text/javascript" === mimeType) return "script";
+    return "other";
+}
+function isRecord(value) {
+    return "object" == typeof value && null !== value;
+}
+exports.createAssetManagerPlugin = __webpack_exports__.createAssetManagerPlugin;
+exports.createAssetReference = __webpack_exports__.createAssetReference;
+exports.getAssetRegistry = __webpack_exports__.getAssetRegistry;
+exports.uploadAsset = __webpack_exports__.uploadAsset;
+exports.validateSelectedFile = __webpack_exports__.validateSelectedFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAssetManagerPlugin",
+    "createAssetReference",
+    "getAssetRegistry",
+    "uploadAsset",
+    "validateSelectedFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin.d.cts

@@ -0,0 +1,9 @@
+import type { StudioPlugin, StudioPluginContext } from "@anvilkit/core/types";
+import { createAssetReference } from "./asset-reference.js";
+import type { AssetManagerOptions, AssetRegistry, UploadResult } from "./types.js";
+export { createAssetReference };
+export declare function createAssetManagerPlugin(options: AssetManagerOptions): StudioPlugin;
+export declare function getAssetRegistry(ctx: StudioPluginContext): AssetRegistry | undefined;
+export declare function uploadAsset(ctx: StudioPluginContext, file: File): Promise<UploadResult>;
+export declare function validateSelectedFile(file: File, options: Pick<AssetManagerOptions, "acceptedMimeTypes" | "maxFileSize">): void;
+//# sourceMappingURL=plugin.d.cts.map

package/dist/plugin.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.cts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,YAAY,EACZ,mBAAmB,EAEnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAO5D,OAAO,KAAK,EACX,mBAAmB,EAEnB,aAAa,EACb,YAAY,EACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAwBhC,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,mBAAmB,GAC1B,YAAY,CAwDd;AAED,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,mBAAmB,GACtB,aAAa,GAAG,SAAS,CAG3B;AAED,wBAAsB,WAAW,CAChC,GAAG,EAAE,mBAAmB,EACxB,IAAI,EAAE,IAAI,GACR,OAAO,CAAC,YAAY,CAAC,CAwCvB;AAED,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,aAAa,CAAC,GACrE,IAAI,CAmBN"}

package/dist/plugin.d.ts

@@ -0,0 +1,9 @@
+import type { StudioPlugin, StudioPluginContext } from "@anvilkit/core/types";
+import { createAssetReference } from "./asset-reference.js";
+import type { AssetManagerOptions, AssetRegistry, UploadResult } from "./types.js";
+export { createAssetReference };
+export declare function createAssetManagerPlugin(options: AssetManagerOptions): StudioPlugin;
+export declare function getAssetRegistry(ctx: StudioPluginContext): AssetRegistry | undefined;
+export declare function uploadAsset(ctx: StudioPluginContext, file: File): Promise<UploadResult>;
+export declare function validateSelectedFile(file: File, options: Pick<AssetManagerOptions, "acceptedMimeTypes" | "maxFileSize">): void;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,YAAY,EACZ,mBAAmB,EAEnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAO5D,OAAO,KAAK,EACX,mBAAmB,EAEnB,aAAa,EACb,YAAY,EACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAwBhC,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,mBAAmB,GAC1B,YAAY,CAwDd;AAED,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,mBAAmB,GACtB,aAAa,GAAG,SAAS,CAG3B;AAED,wBAAsB,WAAW,CAChC,GAAG,EAAE,mBAAmB,EACxB,IAAI,EAAE,IAAI,GACR,OAAO,CAAC,YAAY,CAAC,CAwCvB;AAED,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,aAAa,CAAC,GACrE,IAAI,CAmBN"}

package/dist/plugin.js

@@ -0,0 +1,212 @@
+import { createAssetReference } from "./asset-reference.js";
+import { AssetValidationError } from "./errors.js";
+import { uploadAssetAction } from "./header-action.js";
+import { inferAssetKind } from "./infer-kind.js";
+import { createAssetRegistry } from "./registry.js";
+import { createIRAssetResolver } from "./resolver.js";
+import { createStudioAssetSource } from "./studio-asset-source.js";
+import { validateUploadResult } from "./validate-upload-result.js";
+const META = {
+    id: "anvilkit-plugin-asset-manager",
+    name: "Asset Manager",
+    version: "1.0.0",
+    coreVersion: "^0.1.0-alpha",
+    description: "Headless asset upload plugin with host-provided persistence and a separate React UI subpath."
+};
+const stateByToken = new WeakMap();
+const tokenByContext = new WeakMap();
+function createAssetManagerPlugin(options) {
+    const token = {};
+    const registry = createAssetRegistry();
+    const normalizedOptions = normalizeOptions(options);
+    const assetResolver = createIRAssetResolver({
+        registry,
+        dataUrlAllowlistOptIn: normalizedOptions.dataUrlAllowlistOptIn,
+        allowMixedScriptHostnames: normalizedOptions.allowMixedScriptHostnames
+    });
+    return {
+        meta: META,
+        register (_ctx) {
+            const registration = {
+                meta: META,
+                headerActions: [
+                    uploadAssetAction
+                ],
+                hooks: {
+                    onInit (initCtx) {
+                        const cleanups = [];
+                        stateByToken.set(token, {
+                            options: normalizedOptions,
+                            registry,
+                            cleanups
+                        });
+                        tokenByContext.set(initCtx, token);
+                        initCtx.registerAssetResolver(assetResolver);
+                        const studioAssetSource = createStudioAssetSource({
+                            registry,
+                            upload: (file)=>uploadAsset(initCtx, file),
+                            ...normalizedOptions.getThumbnail ? {
+                                getThumbnail: normalizedOptions.getThumbnail
+                            } : {}
+                        });
+                        const unregisterAssetSource = initCtx.registerAssetSource?.(studioAssetSource);
+                        if (void 0 !== unregisterAssetSource) cleanups.push(unregisterAssetSource);
+                    },
+                    onDestroy (destroyCtx) {
+                        const state = stateByToken.get(token);
+                        if (void 0 !== state) for (const cleanup of state.cleanups)cleanup();
+                        tokenByContext.delete(destroyCtx);
+                        stateByToken.delete(token);
+                    }
+                }
+            };
+            return registration;
+        }
+    };
+}
+function getAssetRegistry(ctx) {
+    const token = tokenByContext.get(ctx);
+    return token ? stateByToken.get(token)?.registry : void 0;
+}
+async function uploadAsset(ctx, file) {
+    const state = getRuntimeState(ctx);
+    const { options, registry } = state;
+    try {
+        validateSelectedFile(file, options);
+        const uploadResult = await options.uploader(file);
+        const validated = validateUploadResult(mergeUploadMeta(uploadResult, file), options);
+        const tagged = withDerivedTags(validated, file);
+        const stored = registry.register(tagged);
+        dispatchAssetReference(ctx, stored);
+        ctx.emit("asset-manager:uploaded", {
+            asset: stored,
+            reference: createAssetReference(stored.id)
+        });
+        return stored;
+    } catch (error) {
+        const normalizedError = error instanceof AssetValidationError ? error : new AssetValidationError("UPLOAD_FAILED", error instanceof Error ? error.message : String(error), {
+            cause: error
+        });
+        ctx.emit("asset-manager:error", {
+            code: normalizedError.code,
+            message: normalizedError.message
+        });
+        ctx.log("error", normalizedError.message, {
+            code: normalizedError.code
+        });
+        throw normalizedError;
+    }
+}
+function validateSelectedFile(file, options) {
+    if (void 0 !== options.maxFileSize && file.size > options.maxFileSize) throw new AssetValidationError("FILE_TOO_LARGE", `File size ${file.size} bytes exceeds the configured maxFileSize of ${options.maxFileSize} bytes.`);
+    if (options.acceptedMimeTypes && options.acceptedMimeTypes.length > 0 && !mimeTypeMatches(file.type, options.acceptedMimeTypes)) {
+        const mimeType = file.type || "unknown";
+        throw new AssetValidationError("UNSUPPORTED_MIME_TYPE", `File MIME type "${mimeType}" is not in acceptedMimeTypes.`);
+    }
+}
+function getRuntimeState(ctx) {
+    const token = tokenByContext.get(ctx);
+    const state = token ? stateByToken.get(token) : void 0;
+    if (!state) throw new Error("createAssetManagerPlugin: uploadAsset called before the plugin runtime was initialized.");
+    return state;
+}
+function normalizeOptions(options) {
+    return {
+        ...options,
+        ...options.acceptedMimeTypes ? {
+            acceptedMimeTypes: Object.freeze([
+                ...options.acceptedMimeTypes
+            ])
+        } : {}
+    };
+}
+function withDerivedTags(asset, file) {
+    if (void 0 !== asset.tags && asset.tags.length > 0) return asset;
+    const tags = new Set();
+    const kind = inferAssetKind(asset);
+    if ("other" !== kind) tags.add(kind);
+    for (const token of filenameTokens(file.name)){
+        if (tags.size >= 3) break;
+        tags.add(token);
+    }
+    if (0 === tags.size) return asset;
+    return {
+        ...asset,
+        tags: Object.freeze([
+            ...tags
+        ])
+    };
+}
+function filenameTokens(name) {
+    const stem = name.replace(/\.[^./\\]+$/, "");
+    const tokens = stem.toLowerCase().split(/[^a-z0-9]+/).filter((token)=>token.length >= 2 && !/^\d+$/.test(token));
+    return tokens.slice(0, 2);
+}
+function mergeUploadMeta(result, file) {
+    const meta = {
+        size: file.size,
+        ...file.type ? {
+            mimeType: file.type
+        } : {},
+        ...result.meta ?? {}
+    };
+    return {
+        ...result,
+        ...void 0 === result.name && file.name ? {
+            name: file.name
+        } : {},
+        meta
+    };
+}
+function mimeTypeMatches(input, acceptedMimeTypes) {
+    if ("" === input) return false;
+    return acceptedMimeTypes.some((accepted)=>{
+        if (accepted.endsWith("/*")) {
+            const prefix = accepted.slice(0, accepted.length - 1);
+            return input.startsWith(prefix);
+        }
+        return input === accepted;
+    });
+}
+function dispatchAssetReference(ctx, asset) {
+    const currentData = ctx.getData();
+    const currentAssetsRaw = Array.isArray(currentData.assets) ? currentData.assets : [];
+    const assetEntry = toIRAsset(asset);
+    const nextAssets = [];
+    let replaced = false;
+    for (const entry of currentAssetsRaw)if (isRecord(entry) && "string" == typeof entry.id && entry.id === asset.id) {
+        nextAssets.push(assetEntry);
+        replaced = true;
+    } else nextAssets.push(entry);
+    if (!replaced) nextAssets.push(assetEntry);
+    const nextData = {
+        ...currentData,
+        assets: nextAssets
+    };
+    ctx.getPuckApi().dispatch({
+        type: "setData",
+        data: nextData
+    });
+}
+function toIRAsset(asset) {
+    return {
+        id: asset.id,
+        kind: inferIRAssetKind(asset.meta?.mimeType, asset.url),
+        url: createAssetReference(asset.id),
+        ...asset.meta ? {
+            meta: asset.meta
+        } : {}
+    };
+}
+function inferIRAssetKind(mimeType, url) {
+    if (mimeType?.startsWith("image/")) return "image";
+    if (mimeType?.startsWith("video/")) return "video";
+    if (mimeType?.startsWith("font/") || /\.(?:woff2?|ttf|otf)(?:$|[?#])/i.test(url)) return "font";
+    if ("text/css" === mimeType) return "style";
+    if ("application/javascript" === mimeType || "text/javascript" === mimeType) return "script";
+    return "other";
+}
+function isRecord(value) {
+    return "object" == typeof value && null !== value;
+}
+export { createAssetManagerPlugin, createAssetReference, getAssetRegistry, uploadAsset, validateSelectedFile };