@dreamerbird/camera-studio 0.0.0-stage → 0.2.0

package/dist/assetLibrary/importPipeline.js

@@ -0,0 +1,253 @@
+import { translate } from '@dreamerbird/studio/i18n';
+import { classifyModel, validatePoseJson } from './classify';
+import { createGLTFLoader } from './gltfLoader';
+import { exportAnimationGLB, exportModelGLB } from './exportGLB';
+import { hashBytes } from './hash';
+import { collectBoneNames, meshStats, rigIdOf } from './rig';
+export const realImportDeps = () => ({
+    load: defaultLoad,
+    exportModel: exportModelGLB,
+    exportAnimation: exportAnimationGLB,
+});
+async function defaultLoad(file) {
+    const { FBXLoader } = await import('three-stdlib');
+    const { LoadingManager } = await import('three');
+    const url = URL.createObjectURL(file);
+    try {
+        if (/\.glb$|\.gltf$/i.test(file.name)) {
+            const gltf = await createGLTFLoader().loadAsync(url);
+            return { root: gltf.scene, animations: gltf.animations };
+        }
+        // FBX 内嵌贴图走 TextureLoader 异步解码:loadAsync 在解析完成时就返回,
+        // 此时 texture.image 还是空的,直接导出会被当无效贴图剥掉(灰模)。
+        // 用 LoadingManager.onLoad 等全部贴图解码完再交卷;贴图加载失败不
+        // 阻塞(manager 照样 onLoad),无效贴图由导出侧的 strip 兜底
+        return await new Promise((resolve, reject) => {
+            const manager = new LoadingManager();
+            let loaded;
+            manager.onLoad = () => {
+                if (loaded)
+                    resolve(loaded);
+            };
+            new FBXLoader(manager).load(url, (root) => {
+                loaded = { root: root, animations: root.animations };
+            }, undefined, reject);
+        });
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}
+export function baseName(fileName) {
+    return fileName.replace(/\.[^.]+$/, '').replace(/\.pose$/, '');
+}
+function summarize(items, tr) {
+    const count = (t) => items.filter((i) => i.type === t).length;
+    const parts = [];
+    if (count('model'))
+        parts.push(tr('pg.import.summary.models', { count: count('model') }));
+    if (count('animation'))
+        parts.push(tr('pg.import.summary.animations', { count: count('animation') }));
+    if (count('pose'))
+        parts.push(tr('pg.import.summary.poses', { count: count('pose') }));
+    if (count('skip'))
+        parts.push(tr('pg.import.summary.skips', { count: count('skip') }));
+    return parts.length
+        ? tr('pg.import.summary.prefix') + parts.join(' + ')
+        : tr('pg.import.summary.empty');
+}
+function newId() {
+    return 'lib-' + Math.random().toString(36).slice(2, 10);
+}
+/**
+ * 识别 + 两层去重,生成导入计划(不落库)。
+ * 第一层:剥动画 GLB 的内容哈希命中 → 跳过模型,仅收新动作;
+ * 第二层:哈希不同但同族 + 顶点/骨骼数相同 → 记入 similar 交给用户。
+ */
+export async function planImport(files, library, deps, tr = translate) {
+    const existing = await library.listEntries();
+    const items = [];
+    const similar = [];
+    for (const file of files) {
+        if (file.name.endsWith('.pose.json')) {
+            let parsed = null;
+            try {
+                parsed = validatePoseJson(JSON.parse(await file.text()));
+            }
+            catch {
+                parsed = null;
+            }
+            if (!parsed) {
+                items.push({
+                    type: 'skip',
+                    name: file.name,
+                    reason: tr('pg.import.reason.badPoseJson'),
+                });
+            }
+            else {
+                items.push({
+                    type: 'pose',
+                    name: baseName(file.name),
+                    rig: parsed.rig,
+                    bones: parsed.bones,
+                });
+            }
+            continue;
+        }
+        let loaded;
+        try {
+            loaded = await deps.load(file);
+        }
+        catch {
+            items.push({
+                type: 'skip',
+                name: file.name,
+                reason: tr('pg.import.reason.parseFailed'),
+            });
+            continue;
+        }
+        const cls = classifyModel(loaded.root, loaded.animations);
+        if (cls === 'unusable') {
+            items.push({
+                type: 'skip',
+                name: file.name,
+                reason: tr('pg.import.reason.noContent'),
+            });
+            continue;
+        }
+        const rig = rigIdOf(loaded.root);
+        if (cls !== 'animations-only') {
+            let glb;
+            try {
+                glb = await deps.exportModel(loaded.root);
+            }
+            catch (err) {
+                // 导出失败(贴图无效等)只跳过模型,不拖垮整批导入;
+                // 下面的动作提取照常——Mixamo 类文件常常就是冲着动作来的
+                console.warn('[assetLibrary] 模型导出失败', err);
+                items.push({
+                    type: 'skip',
+                    name: baseName(file.name),
+                    reason: tr('pg.import.reason.modelExportFailed'),
+                });
+            }
+            if (glb) {
+                const contentHash = hashBytes(new Uint8Array(glb));
+                const dup = existing.find((e) => e.kind === 'model' && e.contentHash === contentHash);
+                if (!dup) {
+                    const stats = meshStats(loaded.root);
+                    const boneCount = collectBoneNames(loaded.root).length;
+                    const index = items.push({
+                        type: 'model',
+                        name: baseName(file.name),
+                        rig,
+                        contentHash,
+                        boneCount,
+                        vertexCount: stats.vertexCount,
+                        glb,
+                    }) - 1;
+                    const hit = existing.find((e) => e.kind === 'model' &&
+                        e.rig === rig &&
+                        e.vertexCount === stats.vertexCount &&
+                        e.boneCount === boneCount &&
+                        e.contentHash !== contentHash);
+                    if (hit) {
+                        similar.push({
+                            index,
+                            existingName: hit.name,
+                            newName: baseName(file.name),
+                        });
+                    }
+                }
+                else {
+                    items.push({
+                        type: 'skip',
+                        name: baseName(file.name),
+                        reason: tr('pg.import.reason.modelExists', { name: dup.name }),
+                    });
+                }
+                // dup 命中:模型跳过,下面的动作照常提取
+            }
+        }
+        for (const clip of loaded.animations) {
+            let glb;
+            try {
+                glb = await deps.exportAnimation(loaded.root, clip);
+            }
+            catch (err) {
+                // 单条动作导出失败不影响其它动作
+                console.warn('[assetLibrary] 动作导出失败', err);
+                items.push({
+                    type: 'skip',
+                    name: `${baseName(file.name)}/${clip.name}`,
+                    reason: tr('pg.import.reason.animationExportFailed'),
+                });
+                continue;
+            }
+            const contentHash = hashBytes(new Uint8Array(glb));
+            if (existing.some((e) => e.kind === 'animation' && e.contentHash === contentHash)) {
+                items.push({
+                    type: 'skip',
+                    name: `${baseName(file.name)}/${clip.name}`,
+                    reason: tr('pg.import.reason.animationExists'),
+                });
+                continue;
+            }
+            items.push({
+                type: 'animation',
+                name: clip.name || baseName(file.name),
+                rig,
+                contentHash,
+                duration: clip.duration,
+                glb,
+            });
+        }
+    }
+    return { items, similar, summary: summarize(items, tr) };
+}
+/** 落库:choices 与 plan.similar 一一对应,'reuse' 丢弃对应 model 项 */
+export async function executeImport(plan, choices, library) {
+    const drop = new Set(plan.similar.filter((_, i) => choices[i] === 'reuse').map((s) => s.index));
+    for (let i = 0; i < plan.items.length; i++) {
+        const item = plan.items[i];
+        if (item.type === 'skip')
+            continue;
+        if (item.type === 'model') {
+            if (drop.has(i))
+                continue;
+            await library.putBlobWithEntry(new Blob([item.glb]), (blobId) => ({
+                id: newId(),
+                kind: 'model',
+                name: item.name,
+                rig: item.rig,
+                blobId,
+                contentHash: item.contentHash,
+                boneCount: item.boneCount,
+                vertexCount: item.vertexCount,
+                createdAt: Date.now(),
+            }));
+        }
+        else if (item.type === 'animation') {
+            await library.putBlobWithEntry(new Blob([item.glb]), (blobId) => ({
+                id: newId(),
+                kind: 'animation',
+                name: item.name,
+                rig: item.rig,
+                blobId,
+                contentHash: item.contentHash,
+                duration: item.duration,
+                createdAt: Date.now(),
+            }));
+        }
+        else {
+            await library.putEntry({
+                id: newId(),
+                kind: 'pose',
+                name: item.name,
+                rig: item.rig,
+                bones: item.bones,
+                createdAt: Date.now(),
+            });
+        }
+    }
+}

package/dist/assetLibrary/importPipeline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=importPipeline.test.d.ts.map

package/dist/assetLibrary/importPipeline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importPipeline.test.d.ts","sourceRoot":"","sources":["../../src/assetLibrary/importPipeline.test.ts"],"names":[],"mappings":""}

package/dist/assetLibrary/importPipeline.test.js

@@ -0,0 +1,188 @@
+import { AnimationClip, Bone, Group, BoxGeometry, Mesh, MeshBasicMaterial, } from 'three';
+import { executeImport, planImport } from './importPipeline';
+import { Library } from './library';
+import { makeDictT, zhCN } from '../i18n';
+// 断言中文文案:注入 zh-CN 词典 t,不依赖全局单例语言
+const zhT = makeDictT(zhCN);
+const planImportZh = (files, backend, deps) => planImport(files, backend, deps, zhT);
+function skinnedModel(...bones) {
+    const root = new Group();
+    for (const name of bones) {
+        const b = new Bone();
+        b.name = name;
+        root.add(b);
+    }
+    root.add(new Mesh(new BoxGeometry(), new MeshBasicMaterial()));
+    return root;
+}
+const clip = (name) => new AnimationClip(name, 1.5, []);
+const file = (name, content = 'x') => new File([content], name);
+function depsFor(map) {
+    return {
+        load: async (f) => {
+            const hit = map[f.name];
+            if (!hit)
+                throw new Error('无法解析');
+            return hit;
+        },
+        exportModel: async () => new TextEncoder().encode('model-glb').buffer,
+        exportAnimation: async (_root, c) => new TextEncoder().encode('anim:' + c.name).buffer,
+    };
+}
+function memoryBackend(existing = []) {
+    const entries = new Map(existing.map((e) => [e.id, e]));
+    return {
+        id: 'mock',
+        listEntries: async (kind) => [...entries.values()].filter((e) => !kind || e.kind === kind),
+        getEntry: async (id) => entries.get(id),
+        putEntry: async (e) => void entries.set(e.id, e),
+        deleteEntry: async (id) => void entries.delete(id),
+        putBlob: async () => 'blob-' + Math.random().toString(36).slice(2),
+        getBlobUrl: async () => 'blob:x',
+        deleteBlob: async () => { },
+        listBlobIds: async () => [],
+        getRigAliases: async () => [],
+        putRigAlias: async () => { },
+    };
+}
+describe('planImport', () => {
+    it('模型文件:1 模型 + 动画逐个提取', async () => {
+        const plan = await planImportZh([file('hero.fbx')], memoryBackend(), depsFor({
+            'hero.fbx': {
+                root: skinnedModel('Hips'),
+                animations: [clip('idle'), clip('run')],
+            },
+        }));
+        expect(plan.items.map((i) => i.type)).toEqual([
+            'model',
+            'animation',
+            'animation',
+        ]);
+        expect(plan.items[1]).toMatchObject({ name: 'idle', duration: 1.5 });
+        expect(plan.summary).toContain('模型 ×1');
+        expect(plan.summary).toContain('动作 ×2');
+    });
+    it('纯动画文件:只出动作,不出模型', async () => {
+        const root = new Group();
+        const b = new Bone();
+        b.name = 'Hips';
+        root.add(b);
+        const plan = await planImportZh([file('walk.fbx')], memoryBackend(), depsFor({ 'walk.fbx': { root, animations: [clip('walk')] } }));
+        expect(plan.items.map((i) => i.type)).toEqual(['animation']);
+    });
+    it('模型导出失败:记跳过且不拖垮整批,动作照常提取', async () => {
+        const deps = depsFor({
+            'kate.fbx': {
+                root: skinnedModel('Hips'),
+                animations: [clip('idle')],
+            },
+        });
+        deps.exportModel = async () => {
+            throw new Error('THREE.GLTFExporter: No valid image data found');
+        };
+        // 修复前:planImport 直接拒绝,整批导入无声消失
+        const plan = await planImportZh([file('kate.fbx')], memoryBackend(), deps);
+        expect(plan.items.map((i) => i.type)).toEqual(['skip', 'animation']);
+        expect(plan.items[0]).toMatchObject({
+            name: 'kate',
+            reason: '模型导出失败',
+        });
+    });
+    it('单条动作导出失败:只跳过该条,其余动作保留', async () => {
+        const deps = depsFor({
+            'mix.fbx': {
+                root: skinnedModel('Hips'),
+                animations: [clip('bad'), clip('good')],
+            },
+        });
+        const realExportAnim = deps.exportAnimation;
+        deps.exportAnimation = async (root, c) => {
+            if (c.name === 'bad')
+                throw new Error('export boom');
+            return realExportAnim(root, c);
+        };
+        const plan = await planImportZh([file('mix.fbx')], memoryBackend(), deps);
+        expect(plan.items.map((i) => i.type)).toEqual([
+            'model',
+            'skip',
+            'animation',
+        ]);
+        expect(plan.items[1]).toMatchObject({
+            name: 'mix/bad',
+            reason: '动作导出失败',
+        });
+    });
+    it('完全相同的模型已在库中:跳过模型,只收新动作', async () => {
+        // 第一层去重:contentHash 命中。假导出器输出固定字节,先算出会命中的 hash
+        const probe = await planImportZh([file('a.fbx')], memoryBackend(), depsFor({ 'a.fbx': { root: skinnedModel('Hips'), animations: [] } }));
+        const hash = probe.items[0].contentHash;
+        const existing = {
+            id: 'm0',
+            kind: 'model',
+            name: '角色A',
+            rig: 'rig-x',
+            blobId: 'b',
+            contentHash: hash,
+            boneCount: 1,
+            vertexCount: 24,
+            createdAt: 1,
+        };
+        const plan = await planImportZh([file('b.fbx')], memoryBackend([existing]), depsFor({
+            'b.fbx': { root: skinnedModel('Hips'), animations: [clip('jump')] },
+        }));
+        expect(plan.items.map((i) => i.type)).toEqual(['skip', 'animation']);
+        expect(plan.items[0]).toMatchObject({
+            reason: expect.stringContaining('已存在'),
+        });
+    });
+    it('哈希不同但同族同结构:记入 similar 由用户定', async () => {
+        const existing = {
+            id: 'm0',
+            kind: 'model',
+            name: '角色A',
+            rig: 'rig-x',
+            blobId: 'b',
+            contentHash: 'different',
+            boneCount: 1,
+            vertexCount: 24,
+            createdAt: 1,
+        };
+        // 让 rig 相同:需要真实骨骼名一致——rigIdOf 是真算的,existing.rig 要对上
+        const probePlan = await planImportZh([file('c.fbx')], memoryBackend(), depsFor({ 'c.fbx': { root: skinnedModel('Hips'), animations: [] } }));
+        existing.rig = probePlan.items[0].rig;
+        const plan = await planImportZh([file('c.fbx')], memoryBackend([{ ...existing, contentHash: 'different' }]), depsFor({ 'c.fbx': { root: skinnedModel('Hips'), animations: [] } }));
+        expect(plan.similar).toEqual([
+            { index: 0, existingName: '角色A', newName: 'c' },
+        ]);
+    });
+    it('姿势 JSON / 无法识别 / 解析失败', async () => {
+        const pose = new File([JSON.stringify({ rig: 'rig-x', bones: { Hips: { rotation: [0, 0, 0, 1] } } })], '弓步.pose.json');
+        const plan = await planImportZh([pose, file('empty.fbx'), file('bad.fbx')], memoryBackend(), depsFor({ 'empty.fbx': { root: new Group(), animations: [] } }));
+        expect(plan.items.map((i) => i.type)).toEqual(['pose', 'skip', 'skip']);
+        expect(plan.items[0]).toMatchObject({ name: '弓步', rig: 'rig-x' });
+    });
+});
+describe('executeImport', () => {
+    it('按 choices 丢弃 similar 模型,其余落库并触发事件', async () => {
+        const backend = memoryBackend();
+        const lib = new Library({ sources: [backend] });
+        let events = 0;
+        lib.subscribe(() => events++);
+        const plan = await planImportZh([file('hero.fbx')], backend, depsFor({
+            'hero.fbx': { root: skinnedModel('Hips'), animations: [clip('idle')] },
+        }));
+        plan.similar.push({ index: 0, existingName: '旧', newName: 'hero' });
+        await executeImport(plan, ['reuse'], lib);
+        const entries = await backend.listEntries();
+        expect(entries.map((e) => e.kind)).toEqual(['animation']); // 模型被 reuse 丢弃
+        expect(events).toBe(1);
+    });
+    it('choices 选 keep 时模型照常入库', async () => {
+        const backend = memoryBackend();
+        const lib = new Library({ sources: [backend] });
+        const plan = await planImportZh([file('hero.fbx')], backend, depsFor({ 'hero.fbx': { root: skinnedModel('Hips'), animations: [] } }));
+        plan.similar.push({ index: 0, existingName: '旧', newName: 'hero' });
+        await executeImport(plan, ['keep'], lib);
+        expect((await backend.listEntries('model')).length).toBe(1);
+    });
+});

package/dist/assetLibrary/indexedDBBackend.d.ts

@@ -0,0 +1,31 @@
+import type { WritableLibrarySource } from './source';
+import type { EntryKind, LibraryEntry, RigAlias } from './types';
+/** IndexedDB 实现的库后端:blobs 表存大二进制,entries 表存元数据 */
+export declare class IndexedDBBackend implements WritableLibrarySource {
+    readonly id = "idb";
+    readonly capabilities: {
+        readonly writable: true;
+    };
+    private readonly dbName;
+    private dbPromise;
+    private urlCache;
+    constructor(opts?: {
+        dbName?: string;
+    });
+    private openDB;
+    private db;
+    listEntries(kind?: EntryKind): Promise<LibraryEntry[]>;
+    getEntry(id: string): Promise<LibraryEntry | undefined>;
+    putEntry(entry: LibraryEntry): Promise<void>;
+    deleteEntry(id: string): Promise<void>;
+    putBlob(data: Blob, opts?: {
+        onProgress?: (ratio: number) => void;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    getBlobUrl(blobId: string): Promise<string>;
+    deleteBlob(blobId: string): Promise<void>;
+    listBlobIds(): Promise<string[]>;
+    getRigAliases(): Promise<RigAlias[]>;
+    putRigAlias(alias: RigAlias): Promise<void>;
+}
+//# sourceMappingURL=indexedDBBackend.d.ts.map

package/dist/assetLibrary/indexedDBBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexedDBBackend.d.ts","sourceRoot":"","sources":["../../src/assetLibrary/indexedDBBackend.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,UAAU,CAAA;AACnD,OAAO,KAAK,EAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAA;AAW9D,kDAAkD;AAClD,qBAAa,gBAAiB,YAAW,qBAAqB;IAC5D,QAAQ,CAAC,EAAE,SAAQ;IACnB,QAAQ,CAAC,YAAY;;MAA4B;IAEjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,QAAQ,CAA4B;gBAEhC,IAAI,GAAE;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAM;IAIxC,OAAO,CAAC,MAAM;IAoBd,OAAO,CAAC,EAAE;IAIJ,WAAW,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAOtD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IASvD,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5C,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAStC,OAAO,CACX,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE;QAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAC,GAClE,OAAO,CAAC,MAAM,CAAC;IAaZ,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAe3C,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAczC,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAShC,aAAa,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IASpC,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAQlD"}

package/dist/assetLibrary/indexedDBBackend.js

@@ -0,0 +1,134 @@
+import { hashBytes } from './hash';
+const DB_VERSION = 2;
+function requestToPromise(req) {
+    return new Promise((resolve, reject) => {
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+/** IndexedDB 实现的库后端:blobs 表存大二进制,entries 表存元数据 */
+export class IndexedDBBackend {
+    constructor(opts = {}) {
+        this.id = 'idb';
+        this.capabilities = { writable: true };
+        this.urlCache = new Map();
+        this.dbName = opts.dbName ?? 'toybox-asset-library';
+    }
+    openDB() {
+        return new Promise((resolve, reject) => {
+            const req = indexedDB.open(this.dbName, DB_VERSION);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains('blobs'))
+                    db.createObjectStore('blobs');
+                if (!db.objectStoreNames.contains('entries')) {
+                    const store = db.createObjectStore('entries', { keyPath: 'id' });
+                    store.createIndex('kind', 'kind', { unique: false });
+                }
+                if (!db.objectStoreNames.contains('rigAliases')) {
+                    db.createObjectStore('rigAliases', { keyPath: 'rig' });
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    db() {
+        return (this.dbPromise ?? (this.dbPromise = this.openDB()));
+    }
+    async listEntries(kind) {
+        const db = await this.db();
+        const store = db.transaction('entries', 'readonly').objectStore('entries');
+        const req = kind ? store.index('kind').getAll(kind) : store.getAll();
+        return (await requestToPromise(req));
+    }
+    async getEntry(id) {
+        const db = await this.db();
+        const req = db
+            .transaction('entries', 'readonly')
+            .objectStore('entries')
+            .get(id);
+        return (await requestToPromise(req));
+    }
+    async putEntry(entry) {
+        const db = await this.db();
+        const req = db
+            .transaction('entries', 'readwrite')
+            .objectStore('entries')
+            .put(entry);
+        await requestToPromise(req);
+    }
+    async deleteEntry(id) {
+        const db = await this.db();
+        const req = db
+            .transaction('entries', 'readwrite')
+            .objectStore('entries')
+            .delete(id);
+        await requestToPromise(req);
+    }
+    async putBlob(data, opts) {
+        const id = hashBytes(new Uint8Array(await data.arrayBuffer()));
+        const db = await this.db();
+        const req = db
+            .transaction('blobs', 'readwrite')
+            .objectStore('blobs')
+            .put(data, id);
+        await requestToPromise(req);
+        // 本地 IDB 写入无进度概念;signal 对本地写同样忽略(不可中断)
+        opts?.onProgress?.(1);
+        return id;
+    }
+    async getBlobUrl(blobId) {
+        const cached = this.urlCache.get(blobId);
+        if (cached)
+            return cached;
+        const db = await this.db();
+        const req = db
+            .transaction('blobs', 'readonly')
+            .objectStore('blobs')
+            .get(blobId);
+        const data = (await requestToPromise(req));
+        if (!data)
+            throw new Error(`资产数据不存在: ${blobId}`);
+        const url = URL.createObjectURL(data);
+        this.urlCache.set(blobId, url);
+        return url;
+    }
+    async deleteBlob(blobId) {
+        const cached = this.urlCache.get(blobId);
+        if (cached) {
+            URL.revokeObjectURL(cached);
+            this.urlCache.delete(blobId);
+        }
+        const db = await this.db();
+        const req = db
+            .transaction('blobs', 'readwrite')
+            .objectStore('blobs')
+            .delete(blobId);
+        await requestToPromise(req);
+    }
+    async listBlobIds() {
+        const db = await this.db();
+        const req = db
+            .transaction('blobs', 'readonly')
+            .objectStore('blobs')
+            .getAllKeys();
+        return (await requestToPromise(req));
+    }
+    async getRigAliases() {
+        const db = await this.db();
+        const req = db
+            .transaction('rigAliases', 'readonly')
+            .objectStore('rigAliases')
+            .getAll();
+        return (await requestToPromise(req));
+    }
+    async putRigAlias(alias) {
+        const db = await this.db();
+        const req = db
+            .transaction('rigAliases', 'readwrite')
+            .objectStore('rigAliases')
+            .put(alias);
+        await requestToPromise(req);
+    }
+}

package/dist/assetLibrary/indexedDBBackend.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=indexedDBBackend.test.d.ts.map

package/dist/assetLibrary/indexedDBBackend.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexedDBBackend.test.d.ts","sourceRoot":"","sources":["../../src/assetLibrary/indexedDBBackend.test.ts"],"names":[],"mappings":""}