@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/media/protected/signature.js

@@ -0,0 +1,205 @@
+const DEFAULT_EXPIRATION_SECONDS = 3600, DEFAULT_BATCH_SIZE = 10;
+export async function signUrl(src, config) {
+  const { endpoint, method = "POST", headers = {}, expirationSeconds = DEFAULT_EXPIRATION_SECONDS, oneTimeUse = !1, params = {} } = config, body = JSON.stringify({
+    url: src,
+    expirationSeconds,
+    oneTimeUse,
+    ...params
+  }), response = await fetch(endpoint, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: method !== "GET" ? body : void 0
+  });
+  if (!response.ok)
+    throw Error(`Failed to sign URL: ${response.status} ${response.statusText}`);
+  const data = await response.json();
+  return {
+    url: data.url || data.signedUrl,
+    signature: data.signature,
+    expires: data.expires || Date.now() + expirationSeconds * 1000,
+    oneTimeUse: data.oneTimeUse || oneTimeUse
+  };
+}
+export async function batchSignUrls(sources, config) {
+  const { endpoint, method = "POST", headers = {}, expirationSeconds = DEFAULT_EXPIRATION_SECONDS, oneTimeUse = !1, params = {} } = config, body = JSON.stringify({
+    urls: sources,
+    expirationSeconds,
+    oneTimeUse,
+    ...params
+  }), response = await fetch(endpoint, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: method !== "GET" ? body : void 0
+  });
+  if (!response.ok)
+    throw Error(`Failed to batch sign URLs: ${response.status} ${response.statusText}`);
+  const data = await response.json(), signatures = new Map, errors = new Map;
+  if (Array.isArray(data.results))
+    for (const item of data.results)
+      if (item.error)
+        errors.set(item.url, item.error);
+      else
+        signatures.set(item.url || item.originalUrl, {
+          url: item.signedUrl || item.url,
+          signature: item.signature,
+          expires: item.expires || Date.now() + expirationSeconds * 1000,
+          oneTimeUse: item.oneTimeUse || oneTimeUse
+        });
+  else if (typeof data.signatures === "object") {
+    for (const [url, signed] of Object.entries(data.signatures)) {
+      const s = signed;
+      signatures.set(url, {
+        url: s.signedUrl || s.url || url,
+        signature: s.signature,
+        expires: s.expires || Date.now() + expirationSeconds * 1000,
+        oneTimeUse
+      });
+    }
+    if (data.errors)
+      for (const [url, error] of Object.entries(data.errors))
+        errors.set(url, error);
+  }
+  return { signatures, errors };
+}
+export async function smartBatchSign(sources, config, batchSize = DEFAULT_BATCH_SIZE) {
+  const allSignatures = new Map, allErrors = new Map, batches = [];
+  for (let i = 0;i < sources.length; i += batchSize)
+    batches.push(sources.slice(i, i + batchSize));
+  const results = await Promise.all(batches.map((batch) => batchSignUrls(batch, config)));
+  for (const result of results) {
+    for (const [url, signed] of result.signatures)
+      allSignatures.set(url, signed);
+    for (const [url, error] of result.errors)
+      allErrors.set(url, error);
+  }
+  return { signatures: allSignatures, errors: allErrors };
+}
+export function isSignatureValid(signedUrl) {
+  return signedUrl.expires > Date.now();
+}
+export function getTimeUntilExpiry(signedUrl) {
+  return Math.max(0, signedUrl.expires - Date.now());
+}
+export function shouldRefreshSignature(signedUrl, refreshWindowMs = 300000) {
+  return getTimeUntilExpiry(signedUrl) < refreshWindowMs;
+}
+export async function checkAuthAccess(auth) {
+  if (auth.check)
+    return await auth.check();
+  return !0;
+}
+export function buildAuthParams(auth) {
+  const params = {};
+  if (auth.role)
+    params.role = auth.role;
+  if (auth.permission)
+    params.permission = auth.permission;
+  if (auth.userId)
+    params.userId = auth.userId;
+  return params;
+}
+const signatureCache = new Map;
+export async function getCachedSignature(src, config) {
+  const cacheKey = `${src}:${config.endpoint}`, cached = signatureCache.get(cacheKey);
+  if (cached && isSignatureValid(cached) && !shouldRefreshSignature(cached))
+    return cached;
+  const signed = await signUrl(src, config);
+  signatureCache.set(cacheKey, signed);
+  return signed;
+}
+export function clearSignatureCache() {
+  signatureCache.clear();
+}
+export function pruneSignatureCache() {
+  let pruned = 0;
+  const now = Date.now();
+  for (const [key, signed] of signatureCache)
+    if (signed.expires <= now) {
+      signatureCache.delete(key);
+      pruned++;
+    }
+  return pruned;
+}
+export function generateSignatureRuntime() {
+  return `
+(function() {
+  'use strict';
+
+  if (typeof window === 'undefined') return;
+
+  window.STX = window.STX || {};
+  var cache = new Map();
+
+  window.STX.signUrl = async function(src, config) {
+    var cacheKey = src + ':' + config.endpoint;
+    var cached = cache.get(cacheKey);
+
+    if (cached && cached.expires > Date.now()) {
+      return cached;
+    }
+
+    var response = await fetch(config.endpoint, {
+      method: config.method || 'POST',
+      headers: Object.assign({ 'Content-Type': 'application/json' }, config.headers || {}),
+      body: JSON.stringify({ url: src, expirationSeconds: config.expirationSeconds || 3600 })
+    });
+
+    if (!response.ok) throw new Error('Failed to sign URL');
+
+    var data = await response.json();
+    var signed = {
+      url: data.url || data.signedUrl,
+      signature: data.signature,
+      expires: data.expires || Date.now() + (config.expirationSeconds || 3600) * 1000
+    };
+
+    cache.set(cacheKey, signed);
+    return signed;
+  };
+
+  window.STX.batchSignUrls = async function(sources, config) {
+    var response = await fetch(config.endpoint, {
+      method: config.method || 'POST',
+      headers: Object.assign({ 'Content-Type': 'application/json' }, config.headers || {}),
+      body: JSON.stringify({ urls: sources, expirationSeconds: config.expirationSeconds || 3600 })
+    });
+
+    if (!response.ok) throw new Error('Failed to batch sign URLs');
+
+    return response.json();
+  };
+
+  window.STX.loadProtectedMedia = async function(element, config) {
+    var src = element.dataset.protectedSrc;
+    if (!src) return;
+
+    try {
+      var signed = await window.STX.signUrl(src, config);
+      if (element.tagName === 'IMG') {
+        element.src = signed.url;
+      }
+else if (element.tagName === 'VIDEO') {
+        element.src = signed.url;
+        element.load();
+      }
+else if (element.tagName === 'SOURCE') {
+        element.src = signed.url;
+        element.parentElement.load();
+      }
+    }
+catch (error) {
+      console.error('Failed to load protected media:', error);
+      if (element.dataset.fallback) {
+        element.src = element.dataset.fallback;
+      }
+    }
+  };
+})();
+`.trim();
+}

package/dist/media/shared/cache.d.ts

@@ -0,0 +1,76 @@
+/**
+ * STX Media - Shared Cache Implementation
+ *
+ * Provides disk and memory caching for processed media assets.
+ *
+ * @module media/shared/cache
+ */
+/**
+ * Cache entry metadata
+ */
+export interface CacheEntry<T = unknown> {
+    /** Cache key */
+    key: string;
+    /** Source file path */
+    src: string;
+    /** Source file hash */
+    srcHash: string;
+    /** Source file mtime */
+    srcMtime: number;
+    /** Options hash */
+    optionsHash: string;
+    /** Cached data */
+    data: T;
+    /** When this entry was created */
+    createdAt: number;
+    /** When this entry was last accessed */
+    lastAccessedAt: number;
+}
+/**
+ * Cache configuration
+ */
+export interface CacheConfig {
+    /** Enable caching */
+    enabled: boolean;
+    /** Cache directory */
+    directory: string;
+    /** Max cache age in days */
+    maxAge: number;
+    /** Max cache size in MB */
+    maxSize: number;
+}
+/**
+ * Default cache configuration
+ */
+export declare const defaultCacheConfig: CacheConfig;
+/**
+ * Get item from cache
+ */
+export declare function getCached<T>(src: string, options: Record<string, unknown>, type: 'image' | 'video', config?: CacheConfig): Promise<T | null>;
+/**
+ * Set item in cache
+ */
+export declare function setCached<T>(src: string, options: Record<string, unknown>, data: T, type: 'image' | 'video', config?: CacheConfig): Promise<void>;
+/**
+ * Clear cache for a specific source
+ */
+export declare function clearCacheForSource(src: string, type: 'image' | 'video', config?: CacheConfig): Promise<void>;
+/**
+ * Clear entire cache
+ */
+export declare function clearCache(type: 'image' | 'video' | 'all', config?: CacheConfig): Promise<void>;
+/**
+ * Get cache statistics
+ */
+export declare function getCacheStats(config?: CacheConfig): Promise<{
+    memoryEntries: number;
+    diskEntries: {
+        image: number;
+        video: number;
+    };
+    totalSizeMB: number;
+}>;
+/**
+ * Prune old cache entries
+ */
+export declare function pruneCache(config?: CacheConfig): Promise<number>;

package/dist/media/shared/cache.js

@@ -0,0 +1,132 @@
+import { mkdir, readFile, writeFile, readdir, rm, stat } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { generateCacheKey, hashFile, getFileMtime, fileExists } from "./hash.js";
+const memoryCache = new Map;
+export const defaultCacheConfig = {
+  enabled: !0,
+  directory: ".stx/media-cache",
+  maxAge: 30,
+  maxSize: 500
+};
+async function ensureCacheDir(cacheDir) {
+  try {
+    await mkdir(cacheDir, { recursive: !0 });
+  } catch {}
+}
+function getCacheFilePath(cacheDir, key, type) {
+  return join(cacheDir, type, `${key}.json`);
+}
+async function isCacheValid(entry, srcPath, maxAge) {
+  if ((Date.now() - entry.createdAt) / 86400000 > maxAge)
+    return !1;
+  if (await getFileMtime(srcPath) !== entry.srcMtime)
+    return !1;
+  return !0;
+}
+export async function getCached(src, options, type, config = defaultCacheConfig) {
+  if (!config.enabled)
+    return null;
+  const key = generateCacheKey(src, options), memEntry = memoryCache.get(key);
+  if (memEntry) {
+    if (await isCacheValid(memEntry, src, config.maxAge)) {
+      memEntry.lastAccessedAt = Date.now();
+      return memEntry.data;
+    }
+    memoryCache.delete(key);
+  }
+  const cachePath = getCacheFilePath(config.directory, key, type);
+  if (await fileExists(cachePath))
+    try {
+      const content = await readFile(cachePath, "utf-8"), entry = JSON.parse(content);
+      if (await isCacheValid(entry, src, config.maxAge)) {
+        entry.lastAccessedAt = Date.now();
+        memoryCache.set(key, entry);
+        return entry.data;
+      }
+    } catch {}
+  return null;
+}
+export async function setCached(src, options, data, type, config = defaultCacheConfig) {
+  if (!config.enabled)
+    return;
+  const key = generateCacheKey(src, options), srcHash = await hashFile(src), srcMtime = await getFileMtime(src), entry = {
+    key,
+    src,
+    srcHash,
+    srcMtime,
+    optionsHash: generateCacheKey("", options),
+    data,
+    createdAt: Date.now(),
+    lastAccessedAt: Date.now()
+  };
+  memoryCache.set(key, entry);
+  const cachePath = getCacheFilePath(config.directory, key, type);
+  try {
+    await ensureCacheDir(dirname(cachePath));
+    await writeFile(cachePath, JSON.stringify(entry, null, 2));
+  } catch (error) {
+    console.warn(`[stx-media] Failed to write cache: ${error}`);
+  }
+}
+export async function clearCacheForSource(src, type, config = defaultCacheConfig) {
+  for (const [key, entry] of memoryCache.entries())
+    if (entry.src === src)
+      memoryCache.delete(key);
+}
+export async function clearCache(type, config = defaultCacheConfig) {
+  if (type === "all")
+    memoryCache.clear();
+  else
+    memoryCache.clear();
+  const typeDirs = type === "all" ? ["image", "video"] : [type];
+  for (const typeDir of typeDirs) {
+    const cacheDir = join(config.directory, typeDir);
+    try {
+      await rm(cacheDir, { recursive: !0, force: !0 });
+    } catch {}
+  }
+}
+export async function getCacheStats(config = defaultCacheConfig) {
+  const stats = {
+    memoryEntries: memoryCache.size,
+    diskEntries: { image: 0, video: 0 },
+    totalSizeMB: 0
+  };
+  for (const type of ["image", "video"]) {
+    const cacheDir = join(config.directory, type);
+    try {
+      const files = await readdir(cacheDir);
+      stats.diskEntries[type] = files.length;
+      for (const file of files) {
+        const filePath = join(cacheDir, file), fileStat = await stat(filePath);
+        stats.totalSizeMB += fileStat.size / 1048576;
+      }
+    } catch {}
+  }
+  return stats;
+}
+export async function pruneCache(config = defaultCacheConfig) {
+  let prunedCount = 0;
+  const maxAgeMs = config.maxAge * 24 * 60 * 60 * 1000;
+  for (const type of ["image", "video"]) {
+    const cacheDir = join(config.directory, type);
+    try {
+      const files = await readdir(cacheDir);
+      for (const file of files) {
+        const filePath = join(cacheDir, file);
+        try {
+          const content = await readFile(filePath, "utf-8"), entry = JSON.parse(content);
+          if (Date.now() - entry.createdAt > maxAgeMs) {
+            await rm(filePath);
+            memoryCache.delete(entry.key);
+            prunedCount++;
+          }
+        } catch {
+          await rm(filePath).catch(() => {});
+          prunedCount++;
+        }
+      }
+    } catch {}
+  }
+  return prunedCount;
+}

package/dist/media/shared/hash.d.ts

@@ -0,0 +1,31 @@
+/**
+ * STX Media - Content Hashing Utilities
+ *
+ * Provides content hashing for cache invalidation.
+ *
+ * @module media/shared/hash
+ */
+/**
+ * Generate SHA-256 hash of file content
+ */
+export declare function hashFile(filePath: string): Promise<string>;
+/**
+ * Generate hash from buffer
+ */
+export declare function hashBuffer(buffer: Buffer | Uint8Array): string;
+/**
+ * Generate hash from string
+ */
+export declare function hashString(str: string): string;
+/**
+ * Generate cache key from source path and options
+ */
+export declare function generateCacheKey(src: string, options: Record<string, unknown>): string;
+/**
+ * Get file modification time for cache validation
+ */
+export declare function getFileMtime(filePath: string): Promise<number>;
+/**
+ * Check if file exists
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;

package/dist/media/shared/hash.js

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+export async function hashFile(filePath) {
+  try {
+    const content = await readFile(filePath);
+    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+  } catch {
+    return "";
+  }
+}
+export function hashBuffer(buffer) {
+  return createHash("sha256").update(buffer).digest("hex").slice(0, 16);
+}
+export function hashString(str) {
+  return createHash("sha256").update(str).digest("hex").slice(0, 16);
+}
+export function generateCacheKey(src, options) {
+  const optionsStr = JSON.stringify(options, Object.keys(options).sort());
+  return `${hashString(src)}-${hashString(optionsStr)}`;
+}
+export async function getFileMtime(filePath) {
+  try {
+    return (await stat(filePath)).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+export async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return !0;
+  } catch {
+    return !1;
+  }
+}

package/dist/media/shared/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * STX Media - Shared Utilities
+ *
+ * @module media/shared
+ */
+export * from './hash';
+export * from './cache';

package/dist/media/shared/index.js

@@ -0,0 +1,2 @@
+export * from "./hash.js";
+export * from "./cache.js";