@stacksjs/stx 0.2.94 → 0.2.96

package/dist/media/protected/index.js

@@ -1,2 +1,20 @@
-// @bun
-import"../../chunk-hjv76kcw.js";import{Jj as m,Kj as n,Lj as o,Mj as p}from"../../chunk-qm4yppj5.js";import{Nj as a,Oj as b,Pj as c,Qj as d,Rj as e,Sj as f,Tj as g,Uj as h,Vj as i,Wj as j,Xj as k,Yj as l}from"../../chunk-eqeyaq6g.js";import"../../chunk-3jm3snz8.js";export{c as smartBatchSign,a as signUrl,f as shouldRefreshSignature,n as renderProtectedVideo,m as renderProtectedImg,k as pruneSignatureCache,o as processProtectedMedia,p as parseProtectedArgs,d as isSignatureValid,e as getTimeUntilExpiry,i as getCachedSignature,l as generateSignatureRuntime,j as clearSignatureCache,g as checkAuthAccess,h as buildAuthParams,b as batchSignUrls};
+export {
+  signUrl,
+  batchSignUrls,
+  smartBatchSign,
+  isSignatureValid,
+  getTimeUntilExpiry,
+  shouldRefreshSignature,
+  checkAuthAccess,
+  buildAuthParams,
+  getCachedSignature,
+  clearSignatureCache,
+  pruneSignatureCache,
+  generateSignatureRuntime
+} from "./signature.js";
+export {
+  renderProtectedImg,
+  renderProtectedVideo,
+  processProtectedMedia,
+  parseProtectedArgs
+} from "./component.js";

package/dist/media/protected/signature.js

@@ -1,2 +1,205 @@
-// @bun
-import{Nj as a,Oj as b,Pj as c,Qj as d,Rj as e,Sj as f,Tj as g,Uj as h,Vj as i,Wj as j,Xj as k,Yj as l}from"../../chunk-eqeyaq6g.js";import"../../chunk-3jm3snz8.js";export{c as smartBatchSign,a as signUrl,f as shouldRefreshSignature,k as pruneSignatureCache,d as isSignatureValid,e as getTimeUntilExpiry,i as getCachedSignature,l as generateSignatureRuntime,j as clearSignatureCache,g as checkAuthAccess,h as buildAuthParams,b as batchSignUrls};
+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.js

@@ -1,2 +1,132 @@
-// @bun
-import{Hk as a,Ik as b,Jk as c,Kk as d,Lk as e,Mk as f,Nk as g}from"../../chunk-gqpkp459.js";import"../../chunk-5ggw1dyv.js";import"../../chunk-3jm3snz8.js";export{c as setCached,g as pruneCache,b as getCached,f as getCacheStats,a as defaultCacheConfig,d as clearCacheForSource,e as clearCache};
+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.js

@@ -1,2 +1,35 @@
-// @bun
-import{Sk as a,Tk as b,Uk as c,Vk as d,Wk as e,Xk as f}from"../../chunk-5ggw1dyv.js";import"../../chunk-3jm3snz8.js";export{c as hashString,a as hashFile,b as hashBuffer,e as getFileMtime,d as generateCacheKey,f as fileExists};
+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.js

@@ -1,2 +1,2 @@
-// @bun
-import"../../chunk-ktkmvaa8.js";import{Hk as g,Ik as h,Jk as i,Kk as j,Lk as k,Mk as l,Nk as m}from"../../chunk-gqpkp459.js";import{Sk as a,Tk as b,Uk as c,Vk as d,Wk as e,Xk as f}from"../../chunk-5ggw1dyv.js";import"../../chunk-3jm3snz8.js";export{i as setCached,m as pruneCache,c as hashString,a as hashFile,b as hashBuffer,e as getFileMtime,h as getCached,l as getCacheStats,d as generateCacheKey,f as fileExists,g as defaultCacheConfig,j as clearCacheForSource,k as clearCache};
+export * from "./hash.js";
+export * from "./cache.js";

package/dist/media/types.js

@@ -1 +0,0 @@
-// @bun