@gaoding/cli 0.0.0 → 1.0.0-alpha.25

package/dist/src/features/dam/asset-projection.js

@@ -0,0 +1,278 @@
+import { isSensitiveKey } from "../../platform/redact.js";
+import { parseSafeRemoteAssetUrl } from "../../platform/url-safety.js";
+const publicAssetTypes = new Set([
+    "image",
+    "video",
+    "audio",
+    "font",
+    "template",
+    "file"
+]);
+const internalAssetTypes = new Map([
+    ["gdpic", "image"],
+    ["gdimage", "image"],
+    ["gdvideo", "video"],
+    ["gdaudio", "audio"],
+    ["gdfont", "font"],
+    ["gdtemplate", "template"],
+    ["gdfile", "file"],
+    ["gdslide", "file"]
+]);
+const recognizableAssetKeys = new Set([
+    "asset_id",
+    "id",
+    "content_id",
+    "title",
+    "name",
+    "description",
+    "format",
+    "type",
+    "content_format",
+    "storage_format",
+    "origin_info",
+    "originInfo",
+    "origin_url",
+    "url",
+    "preview",
+    "preview_info",
+    "previewInfo",
+    "cover",
+    "cover_url",
+    "analysis_result",
+    "analysis_status"
+]);
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function publicSourceFormat(value) {
+    const format = nonblank(value);
+    return format !== undefined && !internalAssetTypes.has(format.toLowerCase())
+        ? format
+        : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function findAssetRecord(value) {
+    const queue = [value];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const candidate = queue.shift();
+        if (Array.isArray(candidate)) {
+            queue.push(...candidate);
+            continue;
+        }
+        const item = record(candidate);
+        if (item === undefined || seen.has(item))
+            continue;
+        seen.add(item);
+        if (Object.keys(item).some((key) => recognizableAssetKeys.has(key)))
+            return item;
+        for (const key of ["data", "asset", "asset_info", "item", "result"]) {
+            if (item[key] !== undefined)
+                queue.push(item[key]);
+        }
+    }
+    return undefined;
+}
+function safePublicUrl(value) {
+    const raw = nonblank(value);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const url = parseSafeRemoteAssetUrl(raw);
+        for (const key of [...url.searchParams.keys()]) {
+            if (isSensitiveKey(key))
+                url.searchParams.delete(key);
+        }
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function timestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const milliseconds = Math.abs(value) < 1_000_000_000_000 ? value * 1000 : value;
+        const date = new Date(milliseconds);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    const text = nonblank(value);
+    if (text === undefined)
+        return undefined;
+    const date = new Date(text);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function tags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value
+        .map((item) => typeof item === "string" ? nonblank(item) : nonblank(record(item)?.name))
+        .filter((item) => item !== undefined);
+    return result.length === 0 ? undefined : result;
+}
+function tagIds(tagIdsValue, tagsValue) {
+    const candidates = Array.isArray(tagIdsValue)
+        ? tagIdsValue
+        : Array.isArray(tagsValue)
+            ? tagsValue.map((item) => record(item)?.id)
+            : [];
+    const result = candidates.filter((item) => (typeof item === "string" && item.trim() !== "")
+        || (typeof item === "number" && Number.isFinite(item)));
+    return result.length === 0 ? undefined : result;
+}
+function assetType(item, format, mediaType) {
+    const explicit = nonblank(item.type)?.toLowerCase();
+    if (explicit !== undefined && publicAssetTypes.has(explicit))
+        return explicit;
+    for (const candidate of [item.content_format, item.storage_format, item.format]) {
+        const internalType = internalAssetTypes.get(nonblank(candidate)?.toLowerCase() ?? "");
+        if (internalType !== undefined)
+            return internalType;
+    }
+    const mediaCategory = mediaType?.split("/", 1)[0]?.toLowerCase();
+    if (mediaCategory !== undefined && publicAssetTypes.has(mediaCategory))
+        return mediaCategory;
+    const normalizedFormat = format?.toLowerCase();
+    if (normalizedFormat !== undefined
+        && ["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "heic"].includes(normalizedFormat)) {
+        return "image";
+    }
+    if (normalizedFormat !== undefined
+        && ["mp4", "mov", "webm", "mkv"].includes(normalizedFormat))
+        return "video";
+    if (normalizedFormat !== undefined
+        && ["mp3", "wav", "m4a", "aac", "ogg", "flac"].includes(normalizedFormat)) {
+        return "audio";
+    }
+    return undefined;
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function normalizeAsset(value, fallback) {
+    const item = findAssetRecord(value);
+    if (item === undefined)
+        return undefined;
+    const fallbackAsset = typeof fallback === "object" ? fallback : undefined;
+    const origin = record(item.origin_info) ?? record(item.originInfo);
+    const design = record(item.design_info) ?? record(item.designInfo);
+    const preview = record(item.preview)
+        ?? record(item.preview_info)
+        ?? record(item.previewInfo)
+        ?? record(item.cover);
+    const repository = record(item.repository_info) ?? record(item.repositoryInfo);
+    const folder = record(item.folder_info) ?? record(item.folderInfo);
+    const format = publicSourceFormat(origin?.format) ?? publicSourceFormat(item.format);
+    const mediaType = nonblank(origin?.mime_type)
+        ?? nonblank(item.mime_type)
+        ?? nonblank(item.mimeType);
+    const assetId = nonblank(item.asset_id)
+        ?? nonblank(item.id)
+        ?? nonblank(item.content_id)
+        ?? (typeof fallback === "string" ? fallback : fallbackAsset?.asset_id);
+    if (assetId === undefined)
+        return undefined;
+    return compact({
+        ...fallbackAsset,
+        asset_id: assetId,
+        title: nonblank(item.title) ?? nonblank(item.name) ?? fallbackAsset?.title,
+        description: nonblank(item.description) ?? fallbackAsset?.description,
+        format: format ?? fallbackAsset?.format,
+        type: assetType(item, format, mediaType) ?? fallbackAsset?.type,
+        size: finiteNumber(origin?.size) ?? finiteNumber(item.size) ?? fallbackAsset?.size,
+        url: safePublicUrl(origin?.url ?? item.origin_url ?? item.url) ?? fallbackAsset?.url,
+        cover_url: safePublicUrl(preview?.url ?? item.cover_url ?? item.preview_url) ?? fallbackAsset?.cover_url,
+        width: finiteNumber(design?.width)
+            ?? finiteNumber(preview?.width)
+            ?? finiteNumber(item.width)
+            ?? fallbackAsset?.width,
+        height: finiteNumber(design?.height)
+            ?? finiteNumber(preview?.height)
+            ?? finiteNumber(item.height)
+            ?? fallbackAsset?.height,
+        duration: finiteNumber(design?.duration)
+            ?? finiteNumber(preview?.duration)
+            ?? finiteNumber(item.duration)
+            ?? fallbackAsset?.duration,
+        repository_id: nonblank(item.repository_id)
+            ?? nonblank(repository?.id)
+            ?? nonblank(repository?.repository_id)
+            ?? fallbackAsset?.repository_id,
+        repository_name: nonblank(item.repository_name)
+            ?? nonblank(repository?.name)
+            ?? nonblank(repository?.title)
+            ?? fallbackAsset?.repository_name,
+        folder_id: nonblank(item.folder_id)
+            ?? nonblank(folder?.id)
+            ?? fallbackAsset?.folder_id,
+        folder_name: nonblank(item.folder_name)
+            ?? nonblank(folder?.name)
+            ?? nonblank(folder?.title)
+            ?? fallbackAsset?.folder_name,
+        tags: tags(item.tags),
+        tag_ids: tagIds(item.tag_ids, item.tags) ?? fallbackAsset?.tag_ids,
+        analysis_status: finiteNumber(item.analysis_result)
+            ?? finiteNumber(item.analysis_status)
+            ?? nonblank(item.analysis_result)
+            ?? nonblank(item.analysis_status)
+            ?? fallbackAsset?.analysis_status,
+        created_at: timestamp(item.created_at) ?? fallbackAsset?.created_at,
+        updated_at: timestamp(item.updated_at) ?? fallbackAsset?.updated_at
+    });
+}
+export function projectDamAssetDetail(value, fallback) {
+    const asset = normalizeAsset(value, fallback);
+    if (asset === undefined)
+        return undefined;
+    return compact({
+        asset_id: asset.asset_id,
+        title: asset.title,
+        description: asset.description,
+        format: asset.format,
+        type: asset.type,
+        size: asset.size,
+        url: asset.url,
+        cover_url: asset.cover_url,
+        width: asset.width,
+        height: asset.height,
+        duration: asset.duration,
+        repository_id: asset.repository_id,
+        repository_name: asset.repository_name,
+        folder_id: asset.folder_id,
+        folder_name: asset.folder_name,
+        tag_ids: asset.tag_ids,
+        analysis_status: asset.analysis_status,
+        created_at: asset.created_at,
+        updated_at: asset.updated_at
+    });
+}
+export function projectDamAssetSummary(value) {
+    const asset = normalizeAsset(value);
+    if (asset === undefined)
+        return undefined;
+    return compact({
+        asset_id: asset.asset_id,
+        title: asset.title,
+        format: asset.format,
+        type: asset.type,
+        size: asset.size,
+        url: asset.url,
+        cover_url: asset.cover_url,
+        width: asset.width,
+        height: asset.height,
+        repository_id: asset.repository_id,
+        folder_id: asset.folder_id,
+        folder_name: asset.folder_name,
+        tags: asset.tags,
+        tag_ids: asset.tag_ids,
+        analysis_status: asset.analysis_status,
+        created_at: asset.created_at,
+        updated_at: asset.updated_at
+    });
+}