hd-garden 0.3.8 → 0.3.10

package/ui/core/sha256.mjs

@@ -0,0 +1,66 @@
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+const rotr = (value, bits) => (value >>> bits) | (value << (32 - bits));
+
+/** Synchronous SHA-256 so the browser, Node and editor hosts compute identical hashes. */
+export function sha256Hex(text) {
+  const bytes = new TextEncoder().encode(text);
+  const bitLength = bytes.length * 8;
+  const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+  const data = new Uint8Array(paddedLength);
+  data.set(bytes);
+  data[bytes.length] = 0x80;
+  const view = new DataView(data.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 2 ** 32));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+
+  const hash = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+  const words = new Uint32Array(64);
+
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i += 1) words[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rotr(words[i - 15], 7) ^ rotr(words[i - 15], 18) ^ (words[i - 15] >>> 3);
+      const s1 = rotr(words[i - 2], 17) ^ rotr(words[i - 2], 19) ^ (words[i - 2] >>> 10);
+      words[i] = (words[i - 16] + s0 + words[i - 7] + s1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const choice = (e & f) ^ (~e & g);
+      const t1 = (h + s1 + choice + K[i] + words[i]) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const majority = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (s0 + majority) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + t1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+    hash[0] = (hash[0] + a) >>> 0;
+    hash[1] = (hash[1] + b) >>> 0;
+    hash[2] = (hash[2] + c) >>> 0;
+    hash[3] = (hash[3] + d) >>> 0;
+    hash[4] = (hash[4] + e) >>> 0;
+    hash[5] = (hash[5] + f) >>> 0;
+    hash[6] = (hash[6] + g) >>> 0;
+    hash[7] = (hash[7] + h) >>> 0;
+  }
+
+  return Array.from(hash, (word) => word.toString(16).padStart(8, "0")).join("");
+}

package/ui/core/starters.mjs

@@ -0,0 +1,18 @@
+/**
+ * Spoken starters for "insert an intent block". Editors show `label`, insert
+ * `text`; component names never appear, authors only describe what readers do.
+ */
+export const STARTERS = [
+  { id: "knob", label: "让读者拧一个数", text: "让读者拖动「」，看「」怎么跟着变。" },
+  { id: "steps", label: "让读者一步步走完", text: "分几步演示「」，每一步高亮「」，读者可以前后翻。" },
+  { id: "compare", label: "并排对比两种做法", text: "把「」和「」并排对比，读者切换时能看出「」的差别。" },
+  { id: "grid", label: "让读者点格子看解释", text: "画一张「」的格子图，读者点每一格，显示「」。" },
+  { id: "flow", label: "沿着流程走", text: "沿着「」的流程走一遍，每一步说明「」。" },
+  { id: "checklist", label: "给一张可勾选的清单", text: "列一张「」的清单，读者可以勾选，显示完成了几项。" },
+  { id: "data", label: "用这份数据画图", text: "用同名目录里的「.csv」画图，横轴是「」，纵轴是「」。" },
+];
+
+/** The fence an editor inserts; `text` may be empty for a blank block. */
+export function intentFence(text = "") {
+  return `\`\`\`intent\n${text}\n\`\`\`\n`;
+}

package/ui/core/state.mjs

@@ -0,0 +1,259 @@
+import { analyzeExpr, createBudget, evaluate, ExprError, RESERVED_NAMES } from "./expr.mjs";
+
+export const NAME_PATTERN = /^[a-z][A-Za-z0-9_]*$/u;
+
+export const isValidName = (name) => NAME_PATTERN.test(name) && !RESERVED_NAMES.has(name);
+
+/** Walks the whole tree for State / Let / Data; they are block-wide wherever written. */
+export function collectDecls(root) {
+  const states = [];
+  const lets = [];
+  const data = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (node.t === "el") {
+      if (node.n === "State") {
+        for (const [name, prop] of Object.entries(node.p)) states.push({ name, prop, line: node.l });
+      } else if (node.n === "Let") {
+        for (const [name, prop] of Object.entries(node.p)) lets.push({ name, prop, line: node.l });
+      } else if (node.n === "Data") {
+        const name = node.p.name?.k === "lit" ? node.p.name.v : null;
+        const src = node.p.src?.k === "lit" ? node.p.src.v : null;
+        if (typeof name === "string" && typeof src === "string") data.push({ name, src, line: node.l });
+      }
+    }
+    if (Array.isArray(node.c)) node.c.forEach(visit);
+  };
+  visit(root);
+  return { states, lets, data };
+}
+
+export function defaultStateValues(decls) {
+  const values = {};
+  for (const state of decls.states) {
+    if (state.prop.k === "lit") values[state.name] = state.prop.v;
+  }
+  return values;
+}
+
+/** Topological order of Let; `cycle` lists the names involved when there is one. */
+export function orderLets(lets) {
+  const byName = new Map(lets.map((item) => [item.name, item]));
+  const dependencies = new Map(
+    lets.map((item) => [
+      item.name,
+      item.prop.k === "expr" ? [...analyzeExpr(item.prop.e).names].filter((name) => byName.has(name)) : [],
+    ]),
+  );
+  const order = [];
+  const state = new Map();
+  let cycle = null;
+  const visit = (name, path) => {
+    if (cycle) return;
+    const mark = state.get(name);
+    if (mark === "done") return;
+    if (mark === "active") {
+      cycle = [...path.slice(path.indexOf(name)), name];
+      return;
+    }
+    state.set(name, "active");
+    for (const dependency of dependencies.get(name) ?? []) visit(dependency, [...path, name]);
+    state.set(name, "done");
+    order.push(byName.get(name));
+  };
+  for (const item of lets) visit(item.name, []);
+  return { order: cycle ? [] : order, cycle };
+}
+
+export function lookupFrom(...layers) {
+  return (name) => {
+    for (const layer of layers) {
+      if (layer && Object.hasOwn(layer, name)) return { found: true, value: layer[name] };
+    }
+    return { found: false, value: undefined };
+  };
+}
+
+/**
+ * State values plus every Let, evaluated in dependency order. A Let that
+ * throws becomes `undefined`; `onError(item, error)` lets callers report it.
+ * @param {{ states: any[], lets: any[], data: any[] }} decls
+ * @param {{ stateValues?: Record<string, unknown>, dataValues?: Record<string, unknown>, budget?: { steps: number, max: number }, onError?: (item: any, error: any) => void }} [options]
+ * @returns {Record<string, unknown>}
+ */
+export function computeScope(decls, { stateValues, dataValues = {}, budget = createBudget(), onError } = {}) {
+  const scope = { ...dataValues, ...stateValues };
+  const { order, cycle } = orderLets(decls.lets);
+  if (cycle) {
+    for (const item of decls.lets) scope[item.name] = undefined;
+    return scope;
+  }
+  for (const item of order) {
+    if (item.prop.k === "lit") {
+      scope[item.name] = item.prop.v;
+      continue;
+    }
+    try {
+      scope[item.name] = evaluate(item.prop.e, lookupFrom(scope), budget);
+    } catch (error) {
+      scope[item.name] = undefined;
+      if (onError) onError(item, error);
+      else if (!(error instanceof ExprError)) throw error;
+    }
+  }
+  return scope;
+}
+
+const isPowerOfTwo = (value) => Number.isInteger(value) && value > 0 && (value & (value - 1)) === 0;
+export { isPowerOfTwo };
+
+export function sampleDomain({ from, to, scale = "linear", samples = 64, pow2 = false }) {
+  if (pow2) {
+    const values = [];
+    for (let value = from; value <= to && values.length < 200; value *= 2) values.push(value);
+    return values;
+  }
+  const count = Math.max(2, Math.min(200, Math.trunc(samples)));
+  if (scale === "log") {
+    const low = Math.log(from);
+    const high = Math.log(to);
+    return Array.from({ length: count }, (_, index) => Math.exp(low + ((high - low) * index) / (count - 1)));
+  }
+  return Array.from({ length: count }, (_, index) => from + ((to - from) * index) / (count - 1));
+}
+
+/**
+ * Evaluates each series at every sample of the swept state.
+ * @param {{ states: any[], lets: any[], data: any[] }} decls
+ * @param {{ stateValues: Record<string, unknown>, dataValues?: Record<string, unknown>, sweep: string, domain: any, series: any[], budget?: { steps: number, max: number } }} options
+ */
+export function sweepSeries(decls, { stateValues, dataValues, sweep, domain, series, budget = createBudget(400000) }) {
+  return sampleDomain(domain).map((x) => {
+    const scope = computeScope(decls, { stateValues: { ...stateValues, [sweep]: x }, dataValues, budget, onError: () => {} });
+    const ys = series.map((expression) => {
+      try {
+        const value = evaluate(expression, lookupFrom(scope), budget);
+        return typeof value === "number" ? value : Number.NaN;
+      } catch {
+        return Number.NaN;
+      }
+    });
+    return { x, ys };
+  });
+}
+
+const closeEnough = (actual, expected, tolerance) => {
+  if (typeof actual !== "number" || !Number.isFinite(actual)) return false;
+  if (expected === 0) return Math.abs(actual) <= tolerance;
+  return Math.abs(actual - expected) <= tolerance * Math.abs(expected);
+};
+
+/** Runs block-header `expect` items; returns failures with stable reasons. */
+export function runExpect(decls, expectList, { dataValues = {} } = {}) {
+  const failures = [];
+  if (!Array.isArray(expectList)) return failures;
+  const defaults = defaultStateValues(decls);
+  const stateNames = new Set(decls.states.map((state) => state.name));
+  expectList.forEach((item, index) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      failures.push({ index, reason: "shape", name: null });
+      return;
+    }
+    const given = item.given ?? {};
+    if (typeof given !== "object" || Array.isArray(given)) {
+      failures.push({ index, reason: "shape", name: "given" });
+      return;
+    }
+    const unknownGiven = Object.keys(given).find((name) => !stateNames.has(name));
+    if (unknownGiven) {
+      failures.push({ index, reason: "unknown-state", name: unknownGiven });
+      return;
+    }
+    const scope = computeScope(decls, { stateValues: { ...defaults, ...given }, dataValues, onError: () => {} });
+    for (const [name, expectation] of Object.entries(item)) {
+      if (name === "given") continue;
+      if (!Object.hasOwn(scope, name)) {
+        failures.push({ index, reason: "unknown-name", name });
+        continue;
+      }
+      const actual = scope[name];
+      if (expectation && typeof expectation === "object" && !Array.isArray(expectation)) {
+        const tolerance = typeof expectation.tol === "number" ? expectation.tol : 1e-9;
+        if (!closeEnough(actual, expectation.value, tolerance)) failures.push({ index, reason: "mismatch", name, actual, expected: expectation.value });
+      } else if (typeof expectation === "number") {
+        if (!closeEnough(actual, expectation, 1e-9)) failures.push({ index, reason: "mismatch", name, actual, expected: expectation });
+      } else if (actual !== expectation) {
+        failures.push({ index, reason: "mismatch", name, actual, expected: expectation });
+      }
+    }
+  });
+  return failures;
+}
+
+const NUMBER_CELL = /^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/iu;
+
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quoted) {
+      if (char === '"' && text[index + 1] === '"') {
+        field += '"';
+        index += 1;
+      } else if (char === '"') {
+        quoted = false;
+      } else {
+        field += char;
+      }
+    } else if (char === '"') {
+      quoted = true;
+    } else if (char === ",") {
+      row.push(field);
+      field = "";
+    } else if (char === "\n" || char === "\r") {
+      if (char === "\r" && text[index + 1] === "\n") index += 1;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else {
+      field += char;
+    }
+  }
+  if (field || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+  const [header = [], ...body] = rows.filter((current) => current.some((cell) => cell.trim()));
+  const keys = header.map((cell) => cell.trim());
+  return body.map((cells) =>
+    Object.fromEntries(
+      keys.map((key, index) => {
+        const raw = (cells[index] ?? "").trim();
+        return [key, NUMBER_CELL.test(raw) ? Number(raw) : raw];
+      }),
+    ),
+  );
+}
+
+export const MAX_DATA_BYTES = 200 * 1024;
+
+/** Parses a Data file; returns `{ value }` or `{ error }`. */
+export function parseDataFile(src, text) {
+  if (new TextEncoder().encode(text).length > MAX_DATA_BYTES) return { error: "数据文件超过 200 KB" };
+  const lower = src.toLowerCase();
+  if (lower.endsWith(".json")) {
+    try {
+      const value = JSON.parse(text);
+      if (!value || typeof value !== "object") return { error: "JSON 顶层必须是数组或对象" };
+      return { value };
+    } catch {
+      return { error: "不是有效的 JSON" };
+    }
+  }
+  if (lower.endsWith(".csv")) return { value: parseCsv(text) };
+  return { error: "只支持 .csv 或 .json" };
+}