Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

15.2 KB
Raw Blame
import { withMediaWriteLock } from "./resource-policy.js";
import { assetFormatsForMimeType } from "./asset-formats.js";
import {
  ASSET_IMPORT_FAILURE_CODES,
  assetImportError,
  isAssetImportError
} from "./resource-limits.js";

const DATABASE_NAME = "prompt-case-collector";
const DATABASE_VERSION = 4;
const MEDIA_STORE = "media";
const LEGACY_SCREENSHOT_STORE = "screenshots";
const DERIVED_STORE = "derived-media";
const DERIVED_METADATA_STORE = "derived-metadata";

let databasePromise;

export async function saveMediaBlob(assetId, blob, options = {}) {
  validateAssetId(assetId);
  validateMediaBlob(blob);
  return writeMediaBlob(assetId, blob, options);
}

export async function savePortableAssetBlob(assetId, blob, options = {}) {
  validatePortableAssetRecord(assetId, blob);
  return writeMediaBlob(assetId, blob, options);
}

export function savePortableAssetBlobs(items, options = {}) {
  return withMediaWriteLock(() => writePortableAssetBlobs(items, options));
}

async function writePortableAssetBlobs(items, options) {
  if (!Array.isArray(items)) throw new Error("媒体文件列表无效");
  const ids = new Set();
  let bytes = 0;
  for (const { assetId, blob } of items) {
    validatePortableAssetRecord(assetId, blob);
    if (ids.has(assetId)) throw new Error("媒体文件编号重复");
    ids.add(assetId);
    bytes += blob.size;
  }
  if (!items.length) return;
  if (options.checkCapacity !== false) assertStorageCapacity(await storageEstimate(options.estimateStorage), bytes);
  const transaction = (await openDatabase()).transaction(MEDIA_STORE, "readwrite");
  const completed = transactionAsPromise(transaction);
  try {
    const store = transaction.objectStore(MEDIA_STORE);
    let written = 0;
    let writtenBytes = 0;
    // Queue Blob handles in one transaction; no full-file ArrayBuffer copies.
    // Only transaction completion makes this staged resource group durable.
    for (const { assetId, blob } of items) {
      store.put(blob, assetId).onsuccess = () => {
        written += 1;
        writtenBytes += blob.size;
        options.onProgress?.({ completed: written, total: items.length, writtenBytes, totalBytes: bytes });
      };
    }
    await completed;
  } catch (error) {
    try { transaction.abort(); } catch {}
    await completed.catch(() => {});
    throw mediaStorageWriteError(error);
  }
}

function writeMediaBlob(assetId, blob, options = {}) {
  return withMediaWriteLock(() => writeMediaBlobUnlocked(assetId, blob, options));
}

async function writeMediaBlobUnlocked(assetId, blob, options) {
  if (options.checkCapacity !== false) {
    const estimate = await storageEstimate(options.estimateStorage);
    assertStorageCapacity(estimate, blob.size);
  }
  try {
    const transaction = (await openDatabase()).transaction(MEDIA_STORE, "readwrite");
    const completed = transactionAsPromise(transaction);
    await Promise.all([
      requestAsPromise(transaction.objectStore(MEDIA_STORE).put(blob, assetId)),
      completed
    ]);
  } catch (error) {
    throw mediaStorageWriteError(error);
  }
}

export async function saveSkillPackageBlob(assetId, blob, options = {}) {
  validateAssetId(assetId);
  if (!String(assetId).startsWith("skill-file:")) throw new Error("Skill 包文件缺少有效编号");
  if (!(blob instanceof Blob)) throw new Error("Skill 包文件无效");
  return writeMediaBlob(assetId, blob, options);
}

export async function getMediaBlob(assetId) {
  validateAssetId(assetId);
  const database = await openDatabase();
  const result = await requestAsPromise(
    database.transaction(MEDIA_STORE, "readonly").objectStore(MEDIA_STORE).get(assetId)
  );
  if (result instanceof Blob) return result;
  if (!database.objectStoreNames.contains(LEGACY_SCREENSHOT_STORE)) return null;
  const legacy = await requestAsPromise(
    database.transaction(LEGACY_SCREENSHOT_STORE, "readonly")
      .objectStore(LEGACY_SCREENSHOT_STORE).get(assetId)
  );
  return legacy instanceof Blob ? legacy : null;
}

export async function deleteMediaBlob(assetId) {
  validateAssetId(assetId);
  const database = await openDatabase();
  const stores = [MEDIA_STORE, DERIVED_STORE, DERIVED_METADATA_STORE];
  if (database.objectStoreNames.contains(LEGACY_SCREENSHOT_STORE)) stores.push(LEGACY_SCREENSHOT_STORE);
  const transaction = database.transaction(stores, "readwrite");
  const completed = transactionAsPromise(transaction);
  for (const name of stores) transaction.objectStore(name).delete(assetId);
  await completed;
}

export async function deleteMediaBlobs(assetIds) {
  const ids = [...new Set((Array.isArray(assetIds) ? assetIds : []).map((assetId) => {
    validateAssetId(assetId);
    return assetId;
  }))];
  if (!ids.length) return;
  const database = await openDatabase();
  const stores = [MEDIA_STORE, DERIVED_STORE, DERIVED_METADATA_STORE];
  if (database.objectStoreNames.contains(LEGACY_SCREENSHOT_STORE)) stores.push(LEGACY_SCREENSHOT_STORE);
  const transaction = database.transaction(stores, "readwrite");
  const completed = transactionAsPromise(transaction);
  for (const name of stores) {
    const store = transaction.objectStore(name);
    for (const assetId of ids) store.delete(assetId);
  }
  await completed;
}

export async function getDerivedMetadata(assetId) {
  validateAssetId(assetId);
  const database = await openDatabase();
  const value = await requestAsPromise(
    database.transaction(DERIVED_METADATA_STORE, "readonly").objectStore(DERIVED_METADATA_STORE).get(assetId)
  );
  return value ? normalizeDerivedMetadata(value) : null;
}

export async function getAllDerivedMetadata() {
  const database = await openDatabase();
  const transaction = database.transaction(DERIVED_METADATA_STORE, "readonly");
  const store = transaction.objectStore(DERIVED_METADATA_STORE);
  const [keys, values] = await Promise.all([
    requestAsPromise(store.getAllKeys()),
    requestAsPromise(store.getAll())
  ]);
  return new Map(keys.map((key, index) => [String(key), normalizeDerivedMetadata(values[index])]));
}

export async function saveDerivedMetadata(assetId, value) {
  validateAssetId(assetId);
  const normalized = normalizeDerivedMetadata(value);
  const transaction = (await openDatabase()).transaction(DERIVED_METADATA_STORE, "readwrite");
  const completed = transactionAsPromise(transaction);
  await Promise.all([
    requestAsPromise(transaction.objectStore(DERIVED_METADATA_STORE).put(normalized, assetId)),
    completed
  ]);
  return normalized;
}

export function normalizeDerivedMetadata(value = {}) {
  const colors = (Array.isArray(value.palette?.colors) ? value.palette.colors : [])
    .map((color) => String(color ?? "").trim()).filter((color) => /^#[0-9a-f]{6}$/iu.test(color)).slice(0, 7);
  const paletteVersion = Math.max(0, Math.floor(Number(value.palette?.version) || 0));
  const width = Math.max(0, Math.floor(Number(value.width) || 0));
  const height = Math.max(0, Math.floor(Number(value.height) || 0));
  return {
    ...(width && height ? { width, height } : {}),
    ...(colors.length && paletteVersion ? {
      palette: {
        colors,
        version: paletteVersion,
        source: String(value.palette?.source ?? "local")
      }
    } : {}),
    ...(String(value.mimeType ?? "").trim() ? { mimeType: String(value.mimeType).trim() } : {}),
    ...(Math.max(0, Math.floor(Number(value.byteSize) || 0)) ? { byteSize: Math.floor(Number(value.byteSize)) } : {})
  };
}

export async function getDerivedMedia(assetId) {
  validateAssetId(assetId);
  const database = await openDatabase();
  const value = await requestAsPromise(database.transaction(DERIVED_STORE, "readonly").objectStore(DERIVED_STORE).get(assetId));
  return value ? normalizeDerivedMedia(value) : null;
}

export async function saveDerivedMedia(assetId, value) {
  validateAssetId(assetId);
  const normalized = normalizeDerivedMedia(value);
  const transaction = (await openDatabase()).transaction(DERIVED_STORE, "readwrite");
  const completed = transactionAsPromise(transaction);
  await Promise.all([requestAsPromise(transaction.objectStore(DERIVED_STORE).put(normalized, assetId)), completed]);
  return normalized;
}

export async function deleteDerivedMedia(assetId) {
  validateAssetId(assetId);
  const transaction = (await openDatabase()).transaction([DERIVED_STORE, DERIVED_METADATA_STORE], "readwrite");
  const completed = transactionAsPromise(transaction);
  transaction.objectStore(DERIVED_STORE).delete(assetId);
  transaction.objectStore(DERIVED_METADATA_STORE).delete(assetId);
  await completed;
}

export function normalizeDerivedMedia(value = {}) {
  const thumbnail = value.thumbnail instanceof Blob && value.thumbnail.type.startsWith("image/") ? value.thumbnail : undefined;
  const remoteImages = (Array.isArray(value.remoteImages) ? value.remoteImages : []).flatMap((item) => {
    const url = safeHttpUrl(item?.url);
    const blob = item?.blob instanceof Blob && item.blob.type.startsWith("image/") ? item.blob : null;
    return url && blob ? [{ url, blob }] : [];
  });
  return {
    pageCount: Math.max(0, Math.floor(Number(value.pageCount) || 0)),
    searchText: String(value.searchText ?? "").trim(),
    ...(thumbnail ? { thumbnail } : {}),
    ...(typeof value.animated === "boolean" ? { animated: value.animated } : {}),
    ...(remoteImages.length ? { remoteImages } : {})
  };
}

export async function replaceMediaBlob(assetId, blob, options = {}) {
  const backupAssetId = replacementBackupAssetId(assetId, options.backupAssetId);
  const current = await getMediaBlob(assetId);
  if (current) await saveMediaBlob(backupAssetId, current, { checkCapacity: false });
  else await deleteMediaBlob(backupAssetId);
  await deleteDerivedMedia(assetId);
  await saveMediaBlob(assetId, blob, options);
  return Boolean(current);
}

export async function undoMediaReplacement(assetId, options = {}) {
  const backupAssetId = replacementBackupAssetId(assetId, options.backupAssetId);
  const backup = await getMediaBlob(backupAssetId);
  if (!backup) throw new Error("没有可撤回的媒体替换");
  await deleteDerivedMedia(assetId);
  await saveMediaBlob(assetId, backup, { checkCapacity: false });
  await deleteMediaBlob(backupAssetId);
  return backup;
}

export async function discardMediaReplacementBackup(assetId, options = {}) {
  await deleteMediaBlob(replacementBackupAssetId(assetId, options.backupAssetId));
}

export function assertStorageCapacity(estimate = {}, incomingBytes = 0) {
  const quota = Number(estimate?.quota);
  const usage = Number(estimate?.usage);
  const required = Number(incomingBytes);
  if (!Number.isFinite(required) || required < 0) {
    throw assetImportError(ASSET_IMPORT_FAILURE_CODES.INVALID_FILE, "媒体文件大小无效");
  }
  if (!Number.isFinite(quota) || !Number.isFinite(usage) || quota < usage) return;
  if (quota - usage < required) {
    throw assetImportError(
      ASSET_IMPORT_FAILURE_CODES.STORAGE_INSUFFICIENT,
      `本机可用空间不足:导入需要 ${formatBytes(required)},当前仅剩 ${formatBytes(quota - usage)}`,
      { requiredBytes: required, availableBytes: quota - usage }
    );
  }
}

export function validateMediaBlob(blob) {
  validatePortableAssetBlob(blob);
  const type = String(blob.type || "").toLocaleLowerCase("en-US");
  if (!(type.startsWith("image/") || type.startsWith("video/") || assetFormatsForMimeType(type).length)) {
    throw assetImportError(ASSET_IMPORT_FAILURE_CODES.UNSUPPORTED_FORMAT, "暂不支持这种媒体格式");
  }
}

export function validatePortableAssetRecord(assetId, blob) {
  validateAssetId(assetId);
  // Package files may be empty or use a source format with no browser MIME
  // mapping. Their established namespace keeps ordinary empty media invalid.
  if (String(assetId).startsWith('skill-file:')) {
    if (!(blob instanceof Blob)) throw new Error('Skill 包文件无效');
    return;
  }
  validatePortableAssetBlob(blob);
}

export function validatePortableAssetBlob(blob) {
  if (!(blob instanceof Blob) || !blob.size) {
    throw assetImportError(ASSET_IMPORT_FAILURE_CODES.INVALID_FILE, "媒体文件无效");
  }
}

async function storageEstimate(override) {
  if (typeof override === "function") return override();
  if (globalThis.navigator?.storage?.estimate) return globalThis.navigator.storage.estimate();
  return {};
}

function openDatabase() {
  if (!databasePromise) {
    databasePromise = new Promise((resolve, reject) => {
      const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
      request.onupgradeneeded = (event) => {
        const database = request.result;
        const transaction = request.transaction;
        if (!database.objectStoreNames.contains(DERIVED_STORE)) database.createObjectStore(DERIVED_STORE);
        if (!database.objectStoreNames.contains(DERIVED_METADATA_STORE)) database.createObjectStore(DERIVED_METADATA_STORE);
        const media = database.objectStoreNames.contains(MEDIA_STORE)
          ? transaction.objectStore(MEDIA_STORE)
          : database.createObjectStore(MEDIA_STORE);
        if (event.oldVersion >= 2) return;
        if (!database.objectStoreNames.contains(LEGACY_SCREENSHOT_STORE)) return;
        const cursorRequest = transaction.objectStore(LEGACY_SCREENSHOT_STORE).openCursor();
        cursorRequest.onsuccess = () => {
          const cursor = cursorRequest.result;
          if (!cursor) return;
          media.put(cursor.value, cursor.key);
          cursor.continue();
        };
      };
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error || new Error("无法打开媒体数据库"));
      request.onblocked = () => reject(new Error("媒体数据库正在被占用,请重新打开插件"));
    });
  }
  return databasePromise;
}

function requestAsPromise(request) {
  return new Promise((resolve, reject) => {
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error || new Error("媒体数据库读写失败"));
  });
}

function transactionAsPromise(transaction) {
  return new Promise((resolve, reject) => {
    transaction.oncomplete = () => resolve();
    transaction.onabort = () => reject(transaction.error || new Error("媒体数据库事务已取消"));
    transaction.onerror = () => reject(transaction.error || new Error("媒体数据库事务失败"));
  });
}

function replacementBackupAssetId(assetId, value) {
  validateAssetId(assetId);
  if (value === undefined) return `backup:${assetId}`;
  validateAssetId(value);
  return value;
}

function validateAssetId(assetId) {
  if (typeof assetId !== "string" || !assetId.trim()) throw new Error("媒体缺少有效编号");
}

function safeHttpUrl(value) {
  try {
    const url = new URL(String(value ?? ""));
    return ["http:", "https:"].includes(url.protocol) ? url.href : "";
  } catch {
    return "";
  }
}

function formatBytes(value) {
  const bytes = Math.max(0, Number(value) || 0);
  const mebibyte = 1024 * 1024;
  return bytes >= mebibyte ? `${Math.ceil(bytes / mebibyte)} MiB` : `${Math.ceil(bytes / 1024)} KiB`;
}

export function mediaStorageWriteError(error) {
  if (isAssetImportError(error)) return error;
  const explanation = String(error?.message ?? "").trim();
  return assetImportError(
    ASSET_IMPORT_FAILURE_CODES.STORAGE_WRITE_FAILED,
    explanation ? `文件写入本机资料库失败:${explanation}` : "文件写入本机资料库失败,请检查可用空间后重试",
    {},
    { cause: error }
  );
}