flomotion 0.0.0-stage → 0.2.0

package/dist/chunks/chunk-IUSYVGP6.mjs

@@ -0,0 +1,122 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/core/src/errors.ts
+var CodeCutError = class extends Error {
+  code;
+  fix;
+  details;
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "CodeCutError";
+    this.code = code;
+    this.fix = opts.fix;
+    this.details = opts.details;
+  }
+  toJSON() {
+    return { code: this.code, message: this.message, fix: this.fix, details: this.details };
+  }
+};
+var isCodeCutError = (e) => e instanceof CodeCutError;
+
+// packages/core/src/ast/node.ts
+var isNode = (x) => typeof x === "object" && x !== null && x.$cc === 1;
+var FRAGMENT = "Fragment";
+function flattenChildren(input, out = []) {
+  if (input === void 0 || input === null || input === false || input === true) return out;
+  if (Array.isArray(input)) {
+    for (const c of input) flattenChildren(c, out);
+    return out;
+  }
+  if (isNode(input)) {
+    if (input.name === FRAGMENT) {
+      for (const c of input.children) out.push(c);
+    } else {
+      out.push(input);
+    }
+    return out;
+  }
+  if (typeof input === "string" || typeof input === "number") {
+    out.push(input);
+    return out;
+  }
+  throw new TypeError(`Unsupported child of type ${typeof input}`);
+}
+function walk(node, fn, parent = null, index = 0) {
+  fn(node, parent, index);
+  node.children.forEach((c, i) => {
+    if (isNode(c)) walk(c, fn, node, i);
+  });
+}
+function findById(root, id) {
+  let hit = null;
+  walk(root, (n, p, i) => {
+    if (!hit && n.props.id === id) hit = { node: n, parent: p, index: i };
+  });
+  return hit;
+}
+function cloneNode(n) {
+  return {
+    $cc: 1,
+    name: n.name,
+    props: cloneValue(n.props),
+    children: n.children.map((c) => isNode(c) ? cloneNode(c) : c)
+  };
+}
+function cloneValue(v) {
+  if (Array.isArray(v)) return v.map(cloneValue);
+  if (v && typeof v === "object") {
+    return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, cloneValue(x)]));
+  }
+  return v;
+}
+function serializeNode(n) {
+  return {
+    name: n.name,
+    props: JSON.parse(
+      JSON.stringify(
+        n.props,
+        (_k, v) => typeof v === "function" ? { $expr: Function.prototype.toString.call(v) } : v
+      )
+    ),
+    children: n.children.map((c) => isNode(c) ? serializeNode(c) : c)
+  };
+}
+
+// packages/core/src/jsx/runtime.ts
+function build(type, props) {
+  if (typeof type === "function") return type(props);
+  if (typeof type === "symbol") {
+    return { $cc: 1, name: FRAGMENT, props: {}, children: flattenChildren(props.children) };
+  }
+  throw new CodeCutError("unknown_component", `Unknown element <${String(type)}>`, {
+    fix: "Only components created with defineComponent/defineEffect can be used as JSX tags."
+  });
+}
+function jsx(type, props, _key) {
+  return build(type, props ?? {});
+}
+var jsxs = jsx;
+var jsxDEV = jsx;
+var Fragment = /* @__PURE__ */ Symbol.for("codecut.fragment");
+
+export {
+  __export,
+  CodeCutError,
+  isCodeCutError,
+  isNode,
+  FRAGMENT,
+  flattenChildren,
+  walk,
+  findById,
+  cloneNode,
+  serializeNode,
+  jsx,
+  jsxs,
+  jsxDEV,
+  Fragment
+};

package/dist/chunks/chunk-JCLRAREG.mjs

@@ -0,0 +1,218 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  CODECUT_DIR,
+  classifyFontLicense,
+  emptyLedger,
+  upsertEntry
+} from "./chunk-AVP5XX4G.mjs";
+import {
+  CodeCutError
+} from "./chunk-IUSYVGP6.mjs";
+
+// packages/render/src/fonts/lock.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// packages/render/src/fonts/inspect.ts
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { extname } from "node:path";
+import * as fontkit from "fontkit";
+var sha256 = (buf) => createHash("sha256").update(buf).digest("hex");
+var formatOf = (path) => {
+  switch (extname(path).toLowerCase()) {
+    case ".woff2":
+      return "woff2";
+    case ".woff":
+      return "woff";
+    case ".otf":
+      return "opentype";
+    default:
+      return "truetype";
+  }
+};
+var cache = /* @__PURE__ */ new Map();
+function inspectFont(path) {
+  const buf = readFileSync(path);
+  const key = sha256(buf);
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const raw = fontkit.create(buf);
+  const font = raw.fonts ? raw.fonts[0] : raw;
+  const lic = [font.license, font.licenseURL, font.copyright].filter(Boolean).join(" \n ");
+  const cls = classifyFontLicense(lic);
+  const axes = {};
+  for (const [tag, a] of Object.entries(
+    font.variationAxes ?? {}
+  ))
+    axes[tag] = [a.min, a.max];
+  const info = {
+    family: font.familyName ?? "",
+    fullName: font.fullName ?? "",
+    license: {
+      license: cls.license,
+      url: font.licenseURL || void 0,
+      attributionRequired: false,
+      commercialOk: cls.commercialOk,
+      copyright: font.copyright || void 0
+    },
+    variable: Object.keys(axes).length > 0,
+    axes,
+    weight: font["OS/2"]?.usWeightClass,
+    italic: !!(font["OS/2"]?.fsSelection?.italic || /italic/i.test(font.subfamilyName ?? "")),
+    glyphs: (cp) => !!font.hasGlyphForCodePoint?.(cp)
+  };
+  cache.set(key, info);
+  return info;
+}
+
+// packages/render/src/fonts/lock.ts
+var lockPath = (root) => join(root, CODECUT_DIR, "fonts.lock.json");
+var ledgerPath = (root) => join(root, CODECUT_DIR, "ledger.json");
+var layoutCachePath = (root) => join(root, CODECUT_DIR, "layout-cache.json");
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(value, null, 2) + "\n");
+}
+var readLock = (root) => readJson(lockPath(root), { version: 1, fonts: {} });
+var readLedger = (root) => readJson(ledgerPath(root), emptyLedger());
+var declHash = (d) => sha256(
+  JSON.stringify({
+    f: d.family,
+    s: d.source,
+    w: d.weights,
+    st: d.styles,
+    v: d.variable,
+    a: d.axes,
+    sub: d.subsets,
+    ur: d.unicodeRange
+  })
+);
+function lockEntry(decl, r) {
+  return {
+    family: decl.family,
+    source: decl.source,
+    declHash: declHash(decl),
+    route: r.route,
+    variable: r.variable,
+    axes: r.axes,
+    license: r.license.license,
+    files: r.files.map((f) => ({
+      path: f.rel,
+      hash: f.hash,
+      weight: f.weight,
+      style: f.style,
+      unicodeRange: f.unicodeRange,
+      format: f.format,
+      subset: f.subset
+    }))
+  };
+}
+function recordLedger(root, decl, r) {
+  let ledger = readLedger(root);
+  for (const f of r.files.length ? r.files : [void 0]) {
+    ledger = upsertEntry(ledger, {
+      source: r.route === "local" ? "local" : r.route === "url" ? "url" : "google-fonts",
+      kind: "font",
+      id: f ? `${decl.id}:${f.subset ?? f.style}:${f.hash.slice(0, 8)}` : decl.id,
+      family: decl.family,
+      file: f?.rel ?? "",
+      hash: f?.hash ?? "",
+      license: r.license.license,
+      url: r.url,
+      attributionRequired: r.license.attributionRequired,
+      commercialOk: r.license.commercialOk,
+      title: decl.family
+    });
+  }
+  writeJson(ledgerPath(root), ledger);
+}
+function resolveFromLock(root, decl, lock = readLock(root)) {
+  const system = decl.source === "system";
+  const e = lock.fonts[decl.id];
+  if (system) {
+    return {
+      id: decl.id,
+      family: decl.family,
+      files: [],
+      fallback: decl.fallback ?? [],
+      source: "system",
+      variable: !!decl.variable
+    };
+  }
+  if (!e) {
+    throw new CodeCutError(
+      "font_error",
+      `Font "${decl.id}" (${decl.family}) is not in .codecut/fonts.lock.json`,
+      { fix: "Run `codecut fonts sync` to download and lock it." }
+    );
+  }
+  if (e.declHash !== declHash(decl)) {
+    throw new CodeCutError("font_error", `Font "${decl.id}" changed since it was locked`, {
+      fix: "Run `codecut fonts sync` to refresh the lock for the new declaration."
+    });
+  }
+  const files = [];
+  for (const f of e.files) {
+    const abs = join(root, f.path);
+    if (!existsSync(abs)) {
+      throw new CodeCutError("font_error", `Font "${decl.id}": file ${f.path} is missing`, {
+        fix: "Restore the file or run `codecut fonts sync`.",
+        details: { id: decl.id, path: f.path }
+      });
+    }
+    const hash = sha256(readFileSync2(abs));
+    if (hash !== f.hash) {
+      throw new CodeCutError(
+        "font_error",
+        `Font "${decl.id}": ${f.path} changed on disk (hash mismatch)`,
+        {
+          fix: "If the change is intended, run `codecut fonts sync --update-lock`.",
+          details: { id: decl.id, path: f.path, expected: f.hash, actual: hash }
+        }
+      );
+    }
+    files.push({
+      path: f.path,
+      weight: f.weight,
+      style: f.style,
+      hash: f.hash,
+      unicodeRange: f.unicodeRange,
+      format: f.format
+    });
+  }
+  return {
+    id: decl.id,
+    family: decl.family,
+    files,
+    fallback: decl.fallback ?? [],
+    source: decl.source === "google" ? "google" : /^https?:/.test(decl.source) ? "url" : "local",
+    variable: e.variable,
+    axes: e.axes,
+    license: e.license
+  };
+}
+
+export {
+  sha256,
+  formatOf,
+  inspectFont,
+  lockPath,
+  ledgerPath,
+  layoutCachePath,
+  readJson,
+  writeJson,
+  readLock,
+  readLedger,
+  declHash,
+  lockEntry,
+  recordLedger,
+  resolveFromLock
+};