Genarrative/apps/ai-game-creator-shell/src/view/project-development/resourceCardPreviewModel.ts

import type { ProjectResource } from './resourceProjectionModel';

export const PROJECT_RESOURCE_CARD_PREVIEW_CONCURRENCY = 3;
export const PROJECT_RESOURCE_CARD_PREVIEW_CACHE_LIMIT = 48;
export const PROJECT_RESOURCE_CARD_PREVIEW_CACHE_BYTE_LIMIT = 64 * 1024 * 1024;
export const PROJECT_RESOURCE_CARD_PREVIEW_QUEUE_LIMIT = 96;
export const PROJECT_RESOURCE_CARD_PREVIEW_ACTIVE_QUEUE_RESERVE =
  PROJECT_RESOURCE_CARD_PREVIEW_CONCURRENCY;

export type ProjectResourceCardPreviewKind =
  | 'raster-image'
  | 'media-image'
  | 'video'
  | 'audio'
  | 'code'
  | 'document'
  | 'version'
  | 'placeholder';

export type ProjectResourceImageDimensions = {
  pixelWidth: number;
  pixelHeight: number;
};

export type ProjectResourceCardPreviewPayload = {
  path: string;
  mediaType: string;
  byteLen: number;
  pixelWidth?: number;
  pixelHeight?: number;
  sourceUrl?: string;
  content?: string;
};

export type ProjectResourceCardPreviewTransportPayload = Omit<
  ProjectResourceCardPreviewPayload,
  'sourceUrl'
> & {
  dataUrl?: string;
};

export function projectResourceCardPreviewImageDimensions(
  preview: Pick<
    ProjectResourceCardPreviewPayload,
    'pixelWidth' | 'pixelHeight'
  >,
): ProjectResourceImageDimensions | null {
  const { pixelWidth, pixelHeight } = preview;
  if (pixelWidth === undefined && pixelHeight === undefined) {
    return null;
  }
  if (
    typeof pixelWidth !== 'number' ||
    typeof pixelHeight !== 'number' ||
    !Number.isSafeInteger(pixelWidth) ||
    !Number.isSafeInteger(pixelHeight) ||
    pixelWidth <= 0 ||
    pixelHeight <= 0
  ) {
    throw new Error('图片预览像素尺寸无效');
  }
  return { pixelWidth, pixelHeight };
}

export type ProjectResourceCardPreviewCacheEntry = {
  identity: string;
  retainedBytes: number;
};

export type ProjectResourceCardPreviewState =
  | { status: 'idle' }
  | { status: 'loading' }
  | {
      status: 'loaded';
      preview: ProjectResourceCardPreviewPayload;
    }
  | { status: 'failed'; error: string; retryable: boolean };

export const IDLE_PROJECT_RESOURCE_CARD_PREVIEW = {
  status: 'idle',
} as const satisfies ProjectResourceCardPreviewState;

function normalizedProjectResourceCardPreviewRetainedBytes(
  retainedBytes: number,
) {
  return Number.isSafeInteger(retainedBytes) && retainedBytes >= 0
    ? retainedBytes
    : PROJECT_RESOURCE_CARD_PREVIEW_CACHE_BYTE_LIMIT + 1;
}

export function projectResourceCardPreviewEvictionIdentities(
  entries: readonly ProjectResourceCardPreviewCacheEntry[],
  protectedIdentity: string | null,
): string[] {
  let retainedCount = entries.length;
  let retainedBytes = entries.reduce(
    (total, entry) =>
      total +
      normalizedProjectResourceCardPreviewRetainedBytes(entry.retainedBytes),
    0,
  );
  const evicted = new Set<string>();
  const overBudget = () =>
    retainedCount > PROJECT_RESOURCE_CARD_PREVIEW_CACHE_LIMIT ||
    retainedBytes > PROJECT_RESOURCE_CARD_PREVIEW_CACHE_BYTE_LIMIT;

  for (const entry of entries) {
    if (!overBudget()) {
      break;
    }
    if (entry.identity === protectedIdentity) {
      continue;
    }
    evicted.add(entry.identity);
    retainedCount -= 1;
    retainedBytes -= normalizedProjectResourceCardPreviewRetainedBytes(
      entry.retainedBytes,
    );
  }

  if (overBudget() && protectedIdentity) {
    const protectedEntry = entries.find(
      (entry) => entry.identity === protectedIdentity,
    );
    if (protectedEntry && !evicted.has(protectedEntry.identity)) {
      evicted.add(protectedEntry.identity);
    }
  }

  return Array.from(evicted);
}

const rasterImageExtension = /\.(png|jpe?g|webp)$/iu;
const extendedImageExtension = /\.(gif|svg|avif|bmp)$/iu;
const videoExtension = /\.(mp4|webm|mov)$/iu;

export function projectResourceCardPreviewKind(
  resource: ProjectResource,
): ProjectResourceCardPreviewKind {
  if (resource.category === 'version') {
    return 'version';
  }
  if (resource.category === 'code') {
    return 'code';
  }
  if (resource.category === 'document') {
    return 'document';
  }
  if (resource.category === 'audio') {
    return 'audio';
  }
  const mediaType = resource.mediaType.trim().toLowerCase();
  if (mediaType.startsWith('video/') || videoExtension.test(resource.path)) {
    return 'video';
  }
  if (
    ['image/png', 'image/jpeg', 'image/jpg', 'image/webp'].includes(
      mediaType,
    ) ||
    rasterImageExtension.test(resource.path)
  ) {
    return 'raster-image';
  }
  if (
    mediaType.startsWith('image/') ||
    extendedImageExtension.test(resource.path)
  ) {
    return 'media-image';
  }
  return 'placeholder';
}

export function projectResourceCardPreviewIdentity(input: {
  projectPath: string;
  projectId: string;
  previewVersion?: string;
  resource: ProjectResource;
}) {
  return JSON.stringify([
    input.projectPath,
    input.projectId,
    input.resource.id,
    input.resource.category,
    input.resource.path,
    input.resource.mediaType,
    input.previewVersion ?? '',
  ]);
}

export function summarizeProjectResourceDocument(content: string) {
  return content
    .replace(/!\[[^\]]*\]\([^)]*\)/gu, ' ')
    .replace(/\[([^\]]+)\]\([^)]*\)/gu, '$1')
    .replace(/<[^>]*>/gu, ' ')
    .replace(/[`*_~>#|{}[\]]/gu, ' ')
    .replace(/^\s*[-+]\s+/gmu, '')
    .replace(/\s+/gu, ' ')
    .trim()
    .slice(0, 180);
}