@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-PKZ7RK5N.js

@@ -0,0 +1,281 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  simple
+} from "./chunk-RXATE6FZ.js";
+
+// ../parsers/dist/composition.js
+import * as acorn from "acorn";
+import * as acorn2 from "acorn";
+var CANVAS_DIMENSIONS = {
+  landscape: { width: 1920, height: 1080 },
+  portrait: { width: 1080, height: 1920 },
+  "landscape-4k": { width: 3840, height: 2160 },
+  "portrait-4k": { width: 2160, height: 3840 },
+  square: { width: 1080, height: 1080 },
+  "square-4k": { width: 2160, height: 2160 },
+  "landscape-720p": { width: 1280, height: 720 },
+  "portrait-720p": { width: 720, height: 1280 },
+  "square-720p": { width: 720, height: 720 },
+  // 480 tall at 16:9 is 853.33 wide: 854 keeps both sides even for 4:2:0 encoders.
+  "landscape-480p": { width: 854, height: 480 },
+  "portrait-480p": { width: 480, height: 854 },
+  "square-480p": { width: 480, height: 480 }
+};
+var VALID_CANVAS_RESOLUTIONS = Object.keys(
+  CANVAS_DIMENSIONS
+);
+var COMPOSITION_VARIABLE_TYPES = [
+  "string",
+  "number",
+  "color",
+  "boolean",
+  "enum",
+  "font",
+  "image"
+];
+var FONT_ALIAS_MAP = {
+  // ── Canonical bundled fonts (self-referencing) ────────────────────────
+  inter: "inter",
+  montserrat: "montserrat",
+  outfit: "outfit",
+  nunito: "nunito",
+  oswald: "oswald",
+  "league gothic": "league-gothic",
+  "archivo black": "archivo-black",
+  "space mono": "space-mono",
+  "ibm plex mono": "ibm-plex-mono",
+  "jetbrains mono": "jetbrains-mono",
+  "eb garamond": "eb-garamond",
+  "playfair display": "playfair-display",
+  "source code pro": "source-code-pro",
+  "noto sans jp": "noto-sans-jp",
+  roboto: "roboto",
+  "open sans": "open-sans",
+  lato: "lato",
+  poppins: "poppins",
+  // ── Common aliases → nearest canonical ────────────────────────────────
+  "helvetica neue": "inter",
+  helvetica: "inter",
+  arial: "inter",
+  "helvetica bold": "inter",
+  futura: "montserrat",
+  "din alternate": "montserrat",
+  "arial black": "montserrat",
+  "bebas neue": "league-gothic",
+  "courier new": "jetbrains-mono",
+  courier: "jetbrains-mono",
+  garamond: "eb-garamond",
+  "noto sans japanese": "noto-sans-jp",
+  "segoe ui": "roboto",
+  // ── macOS sans-serif system fonts → inter ─────────────────────────────
+  "sf pro": "inter",
+  "sf pro display": "inter",
+  "sf pro text": "inter",
+  "sf pro rounded": "inter",
+  avenir: "inter",
+  "avenir next": "inter",
+  "lucida grande": "inter",
+  geneva: "inter",
+  optima: "inter",
+  // ── Windows sans-serif system fonts → inter ───────────────────────────
+  verdana: "inter",
+  tahoma: "inter",
+  "trebuchet ms": "inter",
+  calibri: "inter",
+  candara: "inter",
+  corbel: "inter",
+  "lucida sans": "inter",
+  "lucida sans unicode": "inter",
+  // ── Linux sans-serif system fonts → inter ─────────────────────────────
+  "noto sans": "inter",
+  "dejavu sans": "inter",
+  "liberation sans": "inter",
+  // ── Monospace system fonts → jetbrains-mono ───────────────────────────
+  "sf mono": "jetbrains-mono",
+  menlo: "jetbrains-mono",
+  monaco: "jetbrains-mono",
+  consolas: "jetbrains-mono",
+  "lucida console": "jetbrains-mono",
+  "lucida sans typewriter": "jetbrains-mono",
+  "andale mono": "jetbrains-mono",
+  "dejavu sans mono": "jetbrains-mono",
+  "liberation mono": "jetbrains-mono",
+  // ── Serif system fonts → eb-garamond ──────────────────────────────────
+  georgia: "eb-garamond",
+  palatino: "eb-garamond",
+  "palatino linotype": "eb-garamond",
+  "book antiqua": "eb-garamond",
+  cambria: "eb-garamond",
+  times: "eb-garamond",
+  "times new roman": "eb-garamond",
+  "dejavu serif": "eb-garamond",
+  "liberation serif": "eb-garamond"
+};
+var FONT_ALIAS_KEYS = new Set(Object.keys(FONT_ALIAS_MAP));
+var CANONICAL_FONT_DISPLAY_NAMES = {
+  inter: "Inter",
+  montserrat: "Montserrat",
+  outfit: "Outfit",
+  nunito: "Nunito",
+  oswald: "Oswald",
+  "league-gothic": "League Gothic",
+  "archivo-black": "Archivo Black",
+  "space-mono": "Space Mono",
+  "ibm-plex-mono": "IBM Plex Mono",
+  "jetbrains-mono": "JetBrains Mono",
+  "eb-garamond": "EB Garamond",
+  "playfair-display": "Playfair Display",
+  "source-code-pro": "Source Code Pro",
+  "noto-sans-jp": "Noto Sans JP",
+  roboto: "Roboto",
+  "open-sans": "Open Sans",
+  lato: "Lato",
+  poppins: "Poppins"
+};
+function resolveAliasDisplayName(alias) {
+  const slug = FONT_ALIAS_MAP[alias.toLowerCase()];
+  if (!slug) return void 0;
+  return CANONICAL_FONT_DISPLAY_NAMES[slug];
+}
+var DEFAULT_TYPEOF = {
+  string: "string",
+  number: "number",
+  color: "string",
+  boolean: "boolean",
+  enum: "string",
+  font: "string",
+  image: "string"
+};
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function isVariableType(t) {
+  return typeof t === "string" && t in DEFAULT_TYPEOF;
+}
+function isCompositionVariable(v) {
+  if (!isRecord(v)) return false;
+  if (typeof v.id !== "string" || typeof v.label !== "string") return false;
+  if (!isVariableType(v.type)) return false;
+  if (typeof v.default !== DEFAULT_TYPEOF[v.type]) return false;
+  if (v.type === "enum" && !Array.isArray(v.options)) return false;
+  return true;
+}
+function isSafeMediaUrl(url) {
+  const normalized = url.replace(/[\u0000-\u0020]/g, "");
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(normalized);
+  if (!scheme) return true;
+  const proto = scheme[1]?.toLowerCase();
+  if (!proto) return false;
+  if (proto === "https" || proto === "http" || proto === "blob") return true;
+  if (proto === "data") return /^data:image\//i.test(normalized);
+  return false;
+}
+var COMPOSITION_ATTRIBUTES = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.start,
+  COMPOSITION_ATTRIBUTES.duration,
+  COMPOSITION_ATTRIBUTES.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd,
+  COMPOSITION_ATTRIBUTES.legacyTrack
+]);
+var HTML_BODY_CSS_WIDTH_FIRST_RE = /(html\s*,\s*body\s*\{[^}]*?width:\s*)(\d+)px([^}]*?height:\s*)(\d+)px/i;
+var HTML_BODY_CSS_HEIGHT_FIRST_RE = /(html\s*,\s*body\s*\{[^}]*?height:\s*)(\d+)px([^}]*?width:\s*)(\d+)px/i;
+var VIEWPORT_META_SIZE_RE = /(<meta[^>]*name=["']viewport["'][^>]*content=["']width=)(\d+)(,\s*height=)(\d+)/i;
+function parseProgram(script) {
+  try {
+    return acorn2.parse(script, { ecmaVersion: "latest", sourceType: "script" });
+  } catch {
+    return acorn2.parse(script, { ecmaVersion: "latest", sourceType: "module" });
+  }
+}
+function literalString(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+  if (node?.type === "TemplateLiteral" && node.expressions?.length === 0) {
+    return node.quasis?.[0]?.value?.cooked;
+  }
+  return void 0;
+}
+function memberName(node) {
+  if (node?.type !== "MemberExpression") return void 0;
+  if (!node.computed && node.property?.type === "Identifier") return node.property.name;
+  return literalString(node.property);
+}
+function lookupSelector(node, bindings) {
+  if (node?.type === "Identifier") return bindings.get(node.name);
+  if (node?.type !== "CallExpression" || node.callee?.type !== "MemberExpression") {
+    return void 0;
+  }
+  const method = memberName(node.callee);
+  if (method !== "getElementById" && method !== "querySelector") return void 0;
+  const value = literalString(node.arguments?.[0]);
+  if (!value) return void 0;
+  return method === "getElementById" ? `#${value}` : value;
+}
+function extractMediaSrcMutations(script) {
+  try {
+    const ast = parseProgram(script);
+    const bindings = /* @__PURE__ */ new Map();
+    simple(ast, {
+      VariableDeclarator(node) {
+        if (node.id?.type !== "Identifier") return;
+        const selector = lookupSelector(node.init, bindings);
+        if (selector) bindings.set(node.id.name, selector);
+      }
+    });
+    const mutations = [];
+    simple(ast, {
+      AssignmentExpression(node) {
+        if (node.operator !== "=" || memberName(node.left) !== "src") return;
+        const selector = lookupSelector(node.left.object, bindings);
+        if (!selector) return;
+        mutations.push({
+          selector,
+          operation: "src_assignment",
+          raw: script.slice(node.start, node.end)
+        });
+      },
+      CallExpression(node) {
+        if (memberName(node.callee) !== "setAttribute") return;
+        if (literalString(node.arguments?.[0])?.toLowerCase() !== "src") return;
+        const selector = lookupSelector(node.callee.object, bindings);
+        if (!selector) return;
+        mutations.push({
+          selector,
+          operation: "set_attribute",
+          raw: script.slice(node.start, node.end)
+        });
+      }
+    });
+    return mutations;
+  } catch {
+    return [];
+  }
+}
+
+export {
+  COMPOSITION_VARIABLE_TYPES,
+  FONT_ALIAS_KEYS,
+  resolveAliasDisplayName,
+  isCompositionVariable,
+  isSafeMediaUrl,
+  HTML_BODY_CSS_WIDTH_FIRST_RE,
+  HTML_BODY_CSS_HEIGHT_FIRST_RE,
+  VIEWPORT_META_SIZE_RE,
+  extractMediaSrcMutations
+};

package/vendor/framey/dist/chunk-PURHAXFL.js

@@ -0,0 +1,15 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// src/utils/producer.ts
+async function loadProducer() {
+  return await import("./src-JHQGB2S6.js");
+}
+
+export {
+  loadProducer
+};

package/vendor/framey/dist/chunk-Q5X2B5WT.js

@@ -0,0 +1,29 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// src/utils/lintProject.ts
+function hasDefinitiveEntryMismatch(result) {
+  return result.results.some(
+    (entry) => entry.result.findings.some(
+      (finding) => finding.code === "blank_root_with_standalone_composition"
+    )
+  );
+}
+function definitiveEntryMismatchComposition(result) {
+  for (const entry of result.results) {
+    const finding = entry.result.findings.find(
+      (candidate) => candidate.code === "blank_root_with_standalone_composition"
+    );
+    if (finding) return finding.suggestedComposition;
+  }
+  return void 0;
+}
+
+export {
+  hasDefinitiveEntryMismatch,
+  definitiveEntryMismatchComposition
+};

package/vendor/framey/dist/chunk-QAMKOG67.js

@@ -0,0 +1,248 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  FigmaClientError,
+  MAX_FREEZE_BYTES,
+  appendRecord,
+  buildAssetSnippet,
+  createFigmaClient,
+  exceedsFreezeCap,
+  findAllByFigmaNode,
+  freezeBytes,
+  nextId,
+  parseFigmaRef,
+  regenerateIndex,
+  sanitizeSvg,
+  typeDirPath,
+  updateRecord,
+  withFigmaErrors
+} from "./chunk-ZW6DURPF.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+
+// src/commands/figma/asset.ts
+import { existsSync } from "fs";
+import { join, relative } from "path";
+
+// src/commands/figma/download.ts
+async function downloadRender(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`figma render download failed: HTTP ${res.status}`);
+  const declared = Number(res.headers.get("content-length") ?? 0);
+  if (exceedsFreezeCap(declared))
+    throw new Error(
+      `figma render download failed: content-length ${declared} exceeds ${MAX_FREEZE_BYTES} cap`
+    );
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+// src/commands/figma/asset.ts
+function gatherAssetRefs(positionals) {
+  return positionals.flatMap((r) => /^https?:/i.test(r.trim()) ? [r] : r.split(",")).map((r) => r.trim()).filter((r) => r.length > 0);
+}
+function requireNodeRef(refInput) {
+  const ref = parseFigmaRef(refInput);
+  if (!ref.nodeId)
+    throw new Error(
+      `ref "${refInput}" has no node id \u2014 share a link with ?node-id=\u2026 or use fileKey:nodeId`
+    );
+  return { fileKey: ref.fileKey, nodeId: ref.nodeId };
+}
+function reuseExisting(fileKey, nodeId, opts, version, deps, description, entity) {
+  const existing = findAllByFigmaNode(deps.projectDir, fileKey, nodeId).find(
+    (r) => r.provenance.format === opts.format && (r.provenance.scale ?? 1) === (opts.scale ?? 1) && r.provenance.version === version && existsSync(join(deps.projectDir, r.path))
+  );
+  if (!existing) return null;
+  let record = existing;
+  if (description !== void 0 && description !== existing.description || entity !== void 0 && entity !== existing.entity) {
+    record = {
+      ...existing,
+      ...description !== void 0 && { description },
+      ...entity !== void 0 && { entity }
+    };
+    updateRecord(deps.projectDir, record);
+  }
+  return { record, snippet: buildAssetSnippet(record), reused: true };
+}
+async function freezeAndRecord(fileKey, nodeId, url, ext, opts, version, deps, description, entity) {
+  let bytes = await deps.download(url);
+  if (ext === "svg") {
+    const b0 = bytes[0];
+    if (b0 !== 60 && b0 !== 63 && b0 !== 239)
+      throw new Error("figma render returned non-SVG bytes for an svg export \u2014 retry the import");
+    bytes = new TextEncoder().encode(sanitizeSvg(new TextDecoder().decode(bytes)));
+  }
+  const id = nextId(deps.projectDir, "image");
+  const destAbs = join(typeDirPath(deps.projectDir, "image"), `${id}.${ext}`);
+  freezeBytes(bytes, destAbs);
+  const record = {
+    id,
+    type: "image",
+    path: relative(deps.projectDir, destAbs),
+    source: `figma:${fileKey}/${nodeId}`,
+    ...description !== void 0 && { description },
+    ...entity !== void 0 && { entity },
+    provenance: {
+      source: "figma",
+      fileKey,
+      nodeId,
+      version,
+      format: opts.format,
+      scale: opts.scale
+    }
+  };
+  appendRecord(deps.projectDir, record);
+  return { record, snippet: buildAssetSnippet(record), reused: false };
+}
+async function runAssetImport(refInput, opts, deps) {
+  const [result] = await runAssetImportMany([refInput], opts, deps);
+  if (!result) throw new Error(`figma asset import produced no result for "${refInput}"`);
+  return result;
+}
+async function runAssetImportMany(refInputs, opts, deps) {
+  if (refInputs.length === 0) return [];
+  const refs = refInputs.map(requireNodeRef);
+  const fileKey = refs[0].fileKey;
+  const mixed = refs.find((r) => r.fileKey !== fileKey);
+  if (mixed)
+    throw new Error(
+      `all refs in one import must share a fileKey (batch is per-file) \u2014 got ${fileKey} and ${mixed.fileKey}; run separate commands per file`
+    );
+  const { version } = await deps.client.fileVersion(fileKey);
+  const description = normalizeMeta(opts.description);
+  const entity = normalizeMeta(opts.entity);
+  const slots = refs.map(
+    (r) => reuseExisting(fileKey, r.nodeId, opts, version, deps, description, entity)
+  );
+  const nodeIndexes = /* @__PURE__ */ new Map();
+  const missIndexes = [];
+  for (const [i, ref] of refs.entries()) {
+    if (nodeIndexes.has(ref.nodeId)) continue;
+    nodeIndexes.set(ref.nodeId, i);
+    if (slots[i] === null) missIndexes.push(i);
+  }
+  try {
+    if (missIndexes.length > 0) {
+      const missNodeIds = missIndexes.map((i) => refs[i].nodeId);
+      const rendered = await deps.client.renderNodes(fileKey, missNodeIds, opts);
+      const byNode = new Map(rendered.map((r) => [r.nodeId, r]));
+      for (const i of missIndexes) {
+        const nodeId = refs[i].nodeId;
+        const r = byNode.get(nodeId);
+        if (!r || r.url === null)
+          throw new FigmaClientError(
+            "RENDER_FAILED",
+            `figma could not render node ${nodeId} as ${opts.format}`,
+            void 0,
+            "images"
+          );
+        slots[i] = await freezeAndRecord(
+          fileKey,
+          nodeId,
+          r.url,
+          r.ext,
+          opts,
+          version,
+          deps,
+          description,
+          entity
+        );
+      }
+    }
+  } finally {
+    safeRegenerateIndex(deps.projectDir);
+  }
+  return refs.map((ref, i) => {
+    const firstIndex = nodeIndexes.get(ref.nodeId) ?? i;
+    const result = slots[firstIndex];
+    if (!result) throw new Error(`figma asset import produced no result for "${refInputs[i]}"`);
+    return firstIndex === i ? result : { ...result, reused: true };
+  });
+}
+function normalizeMeta(value) {
+  if (value === void 0) return void 0;
+  const cleaned = value.replace(/\s+/g, " ").trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function safeRegenerateIndex(projectDir) {
+  try {
+    regenerateIndex(projectDir);
+  } catch (err) {
+    console.warn(`index.md regeneration failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+var FORMATS = ["png", "svg", "jpg", "pdf"];
+function parseFormat(raw) {
+  for (const f of FORMATS) if (f === raw) return f;
+  throw new Error(`unsupported format "${raw}" \u2014 use one of ${FORMATS.join(", ")}`);
+}
+var asset_default = defineCommand({
+  meta: { name: "asset", description: "Import one or more figma nodes as frozen local assets" },
+  args: {
+    ref: {
+      type: "positional",
+      description: "figma URL, fileKey:nodeId, or fileKey (pass several, or comma-separate ids, to batch)",
+      required: true
+    },
+    format: { type: "string", description: "png | svg | jpg | pdf", default: "svg" },
+    scale: { type: "string", description: "export scale (e.g. 2)" },
+    description: {
+      type: "string",
+      description: "what this asset is (index.md + <img alt>); e.g. the layer's purpose"
+    },
+    entity: {
+      type: "string",
+      description: 'entity name for media-use cache lookups (e.g. "Acme logo")'
+    },
+    dir: { type: "string", description: "project directory", default: "." }
+  },
+  async run({ args }) {
+    await withFigmaErrors("figma:asset", async () => {
+      const t0 = Date.now();
+      const token = process.env.FIGMA_TOKEN ?? "";
+      const client = createFigmaClient({ token });
+      const positionals = (Array.isArray(args._) && args._.length > 0 ? args._ : [args.ref]).map(String);
+      const refs = gatherAssetRefs(positionals);
+      const results = await runAssetImportMany(
+        refs,
+        {
+          format: parseFormat(args.format),
+          scale: args.scale !== void 0 ? Number(args.scale) : void 0,
+          description: args.description,
+          entity: args.entity
+        },
+        { projectDir: args.dir, client, download: downloadRender }
+      );
+      for (const result of results) {
+        const verb = result.reused ? "reused" : "imported";
+        console.log(`${verb} ${result.record.id} \u2192 ${result.record.path}`);
+        console.log(result.snippet.html);
+      }
+      if (results.length > 1) {
+        const rendered = results.filter((r) => !r.reused).length;
+        console.log(
+          rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
+        );
+      }
+      const { trackFigmaImport } = await import("./telemetry-UN55N6U6.js");
+      trackFigmaImport({
+        phase: "asset",
+        reused: results.every((r) => r.reused),
+        durationMs: Date.now() - t0
+      });
+    });
+  }
+});
+
+export {
+  downloadRender,
+  gatherAssetRefs,
+  runAssetImport,
+  runAssetImportMany,
+  asset_default
+};