machinalayout 0.1.0 → 0.2.0

package/dist/chunk-KYWOCAHK.js

@@ -0,0 +1,205 @@
+import {
+  parseMachinaText
+} from "./chunk-BJOQRPPX.js";
+
+// src/text/react/MachinaTextView.tsx
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_POLICY = {
+  variant: "body",
+  wrap: "word",
+  overflow: "clip",
+  align: "start",
+  leading: "normal",
+  blockGap: 8,
+  listGap: 2,
+  valign: "top"
+};
+var INLINE_CODE_FONT = 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace';
+var VARIANT_STYLE = {
+  body: { fontSize: "14px", fontWeight: 400, lineHeight: 1.4 },
+  label: { fontSize: "12px", fontWeight: 500, lineHeight: 1.3 },
+  caption: { fontSize: "11px", fontWeight: 400, lineHeight: 1.25, opacity: 0.8 },
+  title: { fontSize: "18px", fontWeight: 700, lineHeight: 1.25 },
+  mono: { fontSize: "12px", lineHeight: 1.35, fontFamily: INLINE_CODE_FONT }
+};
+function isMachinaTextDocument(value) {
+  return typeof value === "object" && value !== null && "blocks" in value;
+}
+function isMachinaTextSpec(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "text";
+}
+function normalizePositive(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function normalizeNonNegative(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function normalizeLeading(value) {
+  if (value === void 0) return DEFAULT_POLICY.leading;
+  if (value === "tight" || value === "normal" || value === "loose") return value;
+  return normalizePositive(value, resolveLineHeight(DEFAULT_POLICY));
+}
+function normalizeSpecPolicy(spec) {
+  return {
+    variant: spec.variant ?? DEFAULT_POLICY.variant,
+    wrap: spec.wrap ?? DEFAULT_POLICY.wrap,
+    overflow: spec.overflow ?? DEFAULT_POLICY.overflow,
+    align: spec.align ?? DEFAULT_POLICY.align,
+    leading: normalizeLeading(spec.leading),
+    blockGap: normalizeNonNegative(spec.blockGap, DEFAULT_POLICY.blockGap),
+    listGap: normalizeNonNegative(spec.listGap, DEFAULT_POLICY.listGap),
+    valign: spec.valign ?? DEFAULT_POLICY.valign
+  };
+}
+function normalizeText(text) {
+  if (isMachinaTextDocument(text))
+    return { document: text, diagnostics: [], policy: DEFAULT_POLICY };
+  if (isMachinaTextSpec(text)) {
+    const result2 = parseMachinaText(text.source);
+    return {
+      document: result2.document,
+      diagnostics: result2.diagnostics,
+      policy: normalizeSpecPolicy(text)
+    };
+  }
+  const result = parseMachinaText(typeof text === "string" ? { kind: "machina-text", text } : text);
+  return { document: result.document, diagnostics: result.diagnostics, policy: DEFAULT_POLICY };
+}
+function resolveLineHeight(policy) {
+  if (policy.leading === "tight") return 1.15;
+  if (policy.leading === "loose") return 1.6;
+  if (typeof policy.leading === "number") return policy.leading;
+  return VARIANT_STYLE[policy.variant].lineHeight;
+}
+function policyStyle(policy) {
+  const wrapStyle = {
+    word: { whiteSpace: "normal", overflowWrap: "anywhere" },
+    none: { whiteSpace: "nowrap" }
+  };
+  const overflowStyle = {
+    clip: { overflow: "hidden" },
+    ellipsis: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+    scroll: { overflow: "auto" }
+  };
+  const alignStyle = {
+    start: { textAlign: "left" },
+    center: { textAlign: "center" },
+    end: { textAlign: "right" }
+  };
+  const justifyContent = {
+    top: "flex-start",
+    center: "center",
+    bottom: "flex-end"
+  };
+  return {
+    width: "100%",
+    height: "100%",
+    boxSizing: "border-box",
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: justifyContent[policy.valign],
+    minWidth: 0,
+    ...VARIANT_STYLE[policy.variant],
+    lineHeight: resolveLineHeight(policy),
+    ...wrapStyle[policy.wrap],
+    ...overflowStyle[policy.overflow],
+    ...alignStyle[policy.align]
+  };
+}
+function renderInline(inline, key, props) {
+  switch (inline.kind) {
+    case "text":
+      return /* @__PURE__ */ jsx(React.Fragment, { children: inline.text }, key);
+    case "strong":
+      return /* @__PURE__ */ jsx("strong", { children: inline.children.map((c, i) => renderInline(c, `${key}-s-${i}`, props)) }, key);
+    case "emphasis":
+      return /* @__PURE__ */ jsx("em", { children: inline.children.map((c, i) => renderInline(c, `${key}-e-${i}`, props)) }, key);
+    case "code":
+      return /* @__PURE__ */ jsx(
+        "code",
+        {
+          style: {
+            fontFamily: INLINE_CODE_FONT,
+            backgroundColor: "rgba(127, 127, 127, 0.15)",
+            borderRadius: 3,
+            padding: "0 0.25em"
+          },
+          children: inline.text
+        },
+        key
+      );
+    case "link": {
+      const rel = props.linkTarget === "_blank" ? "noreferrer noopener" : void 0;
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          href: inline.href,
+          target: props.linkTarget,
+          rel,
+          onClick: (event) => props.onLinkClick?.(inline.href, event),
+          children: inline.children.map((c, i) => renderInline(c, `${key}-l-${i}`, props))
+        },
+        key
+      );
+    }
+  }
+}
+function renderBulletItem(item, path, props, listGap) {
+  return /* @__PURE__ */ jsxs("li", { style: { marginBottom: listGap }, children: [
+    item.inline.map((i, idx) => renderInline(i, `${path}-i-${idx}`, props)),
+    item.children?.length ? /* @__PURE__ */ jsx("ul", { style: { margin: "0.25em 0 0 0", paddingLeft: "1.25em" }, children: item.children.map((c, idx) => renderBulletItem(c, `${path}-c-${idx}`, props, listGap)) }) : null
+  ] }, path);
+}
+function MachinaTextView(props) {
+  const normalized = normalizeText(props.text);
+  return /* @__PURE__ */ jsx("div", { className: props.className, style: { ...policyStyle(normalized.policy), ...props.style }, children: /* @__PURE__ */ jsxs("div", { style: { minWidth: 0 }, children: [
+    normalized.document.blocks.map(
+      (block, index) => block.kind === "paragraph" ? /* @__PURE__ */ jsx(
+        "p",
+        {
+          style: {
+            margin: index === normalized.document.blocks.length - 1 ? "0" : `0 0 ${normalized.policy.blockGap}px 0`
+          },
+          children: block.inline.map((i, idx) => renderInline(i, `b-${index}-${idx}`, props))
+        },
+        `b-${index}`
+      ) : /* @__PURE__ */ jsx(
+        "ul",
+        {
+          style: {
+            margin: index === normalized.document.blocks.length - 1 ? "0" : `0 0 ${normalized.policy.blockGap}px 0`,
+            paddingLeft: "1.25em"
+          },
+          children: block.items.map(
+            (item, itemIndex) => renderBulletItem(
+              item,
+              `b-${index}-item-${itemIndex}`,
+              props,
+              normalized.policy.listGap
+            )
+          )
+        },
+        `b-${index}`
+      )
+    ),
+    props.showDiagnostics && normalized.diagnostics.length > 0 ? /* @__PURE__ */ jsx(
+      "pre",
+      {
+        style: {
+          margin: `${normalized.policy.blockGap}px 0 0 0`,
+          padding: "0.5em",
+          fontSize: "11px",
+          fontFamily: INLINE_CODE_FONT,
+          whiteSpace: "pre-wrap",
+          background: "rgba(127, 127, 127, 0.12)"
+        },
+        children: normalized.diagnostics.map((d) => `${d.code} (${d.line}:${d.column}) ${d.message}`).join("\n")
+      }
+    ) : null
+  ] }) });
+}
+
+export {
+  MachinaTextView
+};

package/dist/chunk-TR24ERZT.js

@@ -0,0 +1,66 @@
+// src/errors.ts
+var MachinaLayoutError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "MachinaLayoutError";
+    this.code = code;
+  }
+};
+
+// src/toResolvedTree.ts
+function toResolvedTree(document) {
+  const root = document.nodes[document.rootId];
+  if (!root) {
+    throw new MachinaLayoutError("MissingRoot", `root node '${document.rootId}' is missing`);
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const build = (node) => {
+    if (visiting.has(node.id)) {
+      throw new MachinaLayoutError("Cycle", `cycle detected at '${node.id}'`);
+    }
+    visiting.add(node.id);
+    visited.add(node.id);
+    const childIds = document.children[node.id] ?? [];
+    const children = childIds.map((childId) => {
+      const child = document.nodes[childId];
+      if (!child) {
+        throw new MachinaLayoutError(
+          "UnknownParent",
+          `missing child node '${childId}' referenced by '${node.id}'`
+        );
+      }
+      return build(child);
+    });
+    visiting.delete(node.id);
+    return {
+      id: node.id,
+      z: node.z,
+      rect: { ...node.rect },
+      frame: node.frame,
+      arrange: node.arrange,
+      view: node.view,
+      slot: node.slot,
+      debugLabel: node.debugLabel,
+      layer: node.layer,
+      offset: node.offset,
+      children
+    };
+  };
+  const tree = build(root);
+  for (const nodeId of Object.keys(document.nodes)) {
+    if (!visited.has(nodeId)) {
+      throw new MachinaLayoutError(
+        "UnreachableNode",
+        `node '${nodeId}' is unreachable from root '${document.rootId}'`
+      );
+    }
+  }
+  return tree;
+}
+
+export {
+  MachinaLayoutError,
+  toResolvedTree
+};

package/dist/dispatch/index.d.ts

@@ -0,0 +1,49 @@
+type SetDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+    values: readonly unknown[];
+};
+type ToggleDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+};
+type IncrementDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+    by?: readonly number[];
+};
+type PrefixSetDispatchTable<TState> = {
+    prefixes: readonly string[];
+    fields: readonly (keyof TState)[];
+    allowedSuffixes?: readonly (readonly string[] | undefined)[];
+};
+type PrefixIncrementDispatchTable<TState> = {
+    prefixes: readonly string[];
+    fields: readonly (keyof TState)[];
+    by?: readonly number[];
+    allowedSuffixes?: readonly (readonly string[] | undefined)[];
+};
+type MachinaDispatchTables<TState> = {
+    set?: SetDispatchTable<TState>;
+    toggle?: ToggleDispatchTable<TState>;
+    increment?: IncrementDispatchTable<TState>;
+    setSuffix?: PrefixSetDispatchTable<TState>;
+    incrementSuffix?: PrefixIncrementDispatchTable<TState>;
+};
+
+declare function dispatchEvent<TState extends Record<string, unknown>>(state: TState, event: string, tables: MachinaDispatchTables<TState>): TState;
+
+type MachinaDispatchErrorCode = "InvalidDispatchTable" | "InvalidDispatchField" | "InvalidDispatchValue" | "InvalidDispatchEvent";
+declare class MachinaDispatchError extends Error {
+    readonly code: MachinaDispatchErrorCode;
+    constructor(code: MachinaDispatchErrorCode, message: string);
+}
+
+declare function defineDispatchTables<TState>(tables: MachinaDispatchTables<TState>): MachinaDispatchTables<TState>;
+declare function resolveEventValue<TValue>(event: string, table: {
+    events: readonly string[];
+    values: readonly TValue[];
+}): TValue | undefined;
+declare function matchEventPrefix(event: string, prefix: string, allowedSuffixes?: readonly string[]): string | undefined;
+
+export { type IncrementDispatchTable, MachinaDispatchError, type MachinaDispatchErrorCode, type MachinaDispatchTables, type PrefixIncrementDispatchTable, type PrefixSetDispatchTable, type SetDispatchTable, type ToggleDispatchTable, defineDispatchTables, dispatchEvent, matchEventPrefix, resolveEventValue };

package/dist/dispatch/index.js

@@ -0,0 +1,217 @@
+// src/dispatch/errors.ts
+var MachinaDispatchError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "MachinaDispatchError";
+    this.code = code;
+  }
+};
+
+// src/dispatch/helpers.ts
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var validateLengths = (name, ...columns) => {
+  const expected = columns[0]?.length ?? 0;
+  if (!columns.every((column) => Array.isArray(column) && column.length === expected)) {
+    throw new MachinaDispatchError("InvalidDispatchTable", `${name} column lengths must match`);
+  }
+};
+var validateAllowedSuffixes = (allowedSuffixes, expectedLength, tableName) => {
+  if (allowedSuffixes === void 0) return;
+  if (!Array.isArray(allowedSuffixes) || allowedSuffixes.length !== expectedLength) {
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      `${tableName}.allowedSuffixes length mismatch`
+    );
+  }
+  for (const row of allowedSuffixes) {
+    if (row !== void 0 && !isStringArray(row)) {
+      throw new MachinaDispatchError(
+        "InvalidDispatchTable",
+        `${tableName}.allowedSuffixes must be string arrays`
+      );
+    }
+  }
+};
+var validateBy = (by, expectedLength, tableName) => {
+  if (by === void 0) return;
+  if (!Array.isArray(by) || by.length !== expectedLength) {
+    throw new MachinaDispatchError("InvalidDispatchTable", `${tableName}.by length mismatch`);
+  }
+  for (const value of by) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new MachinaDispatchError(
+        "InvalidDispatchTable",
+        `${tableName}.by must contain finite numbers`
+      );
+    }
+  }
+};
+var validateSetTable = (table) => {
+  validateLengths("set", table.events, table.fields, table.values);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "set.events must be strings");
+};
+var validateToggleTable = (table) => {
+  validateLengths("toggle", table.events, table.fields);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "toggle.events must be strings");
+};
+var validateIncrementTable = (table) => {
+  validateLengths("increment", table.events, table.fields);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "increment.events must be strings");
+  validateBy(table.by, table.events.length, "increment");
+};
+var validatePrefixSetTable = (table) => {
+  validateLengths("setSuffix", table.prefixes, table.fields);
+  if (!isStringArray(table.prefixes))
+    throw new MachinaDispatchError("InvalidDispatchTable", "setSuffix.prefixes must be strings");
+  validateAllowedSuffixes(table.allowedSuffixes, table.prefixes.length, "setSuffix");
+};
+var validatePrefixIncrementTable = (table) => {
+  validateLengths("incrementSuffix", table.prefixes, table.fields);
+  if (!isStringArray(table.prefixes))
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      "incrementSuffix.prefixes must be strings"
+    );
+  validateBy(table.by, table.prefixes.length, "incrementSuffix");
+  validateAllowedSuffixes(table.allowedSuffixes, table.prefixes.length, "incrementSuffix");
+};
+function defineDispatchTables(tables) {
+  if (tables.set) validateSetTable(tables.set);
+  if (tables.toggle) validateToggleTable(tables.toggle);
+  if (tables.increment) validateIncrementTable(tables.increment);
+  if (tables.setSuffix) validatePrefixSetTable(tables.setSuffix);
+  if (tables.incrementSuffix) validatePrefixIncrementTable(tables.incrementSuffix);
+  return tables;
+}
+function resolveEventValue(event, table) {
+  validateLengths("resolveEventValue", table.events, table.values);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "events must be strings");
+  for (let i = 0; i < table.events.length; i += 1) {
+    if (table.events[i] === event) return table.values[i];
+  }
+  return void 0;
+}
+function matchEventPrefix(event, prefix, allowedSuffixes) {
+  if (typeof event !== "string" || typeof prefix !== "string") {
+    throw new MachinaDispatchError("InvalidDispatchEvent", "event and prefix must be strings");
+  }
+  if (allowedSuffixes !== void 0 && !isStringArray(allowedSuffixes)) {
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      "allowedSuffixes must be a string array"
+    );
+  }
+  if (!event.startsWith(prefix)) return void 0;
+  const suffix = event.slice(prefix.length);
+  if (allowedSuffixes && !allowedSuffixes.includes(suffix)) return void 0;
+  return suffix;
+}
+
+// src/dispatch/dispatchEvent.ts
+var hasOwn = (state, field) => Object.hasOwn(state, field);
+function dispatchEvent(state, event, tables) {
+  if (typeof event !== "string") {
+    throw new MachinaDispatchError("InvalidDispatchEvent", "event must be a string");
+  }
+  const base = state;
+  if (tables.set) {
+    validateSetTable(tables.set);
+    for (let i = 0; i < tables.set.events.length; i += 1) {
+      if (tables.set.events[i] !== event) continue;
+      const field = tables.set.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const nextValue = tables.set.values[i];
+      if (Object.is(base[field], nextValue)) return state;
+      return { ...state, [field]: nextValue };
+    }
+  }
+  if (tables.toggle) {
+    validateToggleTable(tables.toggle);
+    for (let i = 0; i < tables.toggle.events.length; i += 1) {
+      if (tables.toggle.events[i] !== event) continue;
+      const field = tables.toggle.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "boolean")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be boolean: ${String(field)}`
+        );
+      return { ...state, [field]: !current };
+    }
+  }
+  if (tables.increment) {
+    validateIncrementTable(tables.increment);
+    for (let i = 0; i < tables.increment.events.length; i += 1) {
+      if (tables.increment.events[i] !== event) continue;
+      const field = tables.increment.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "number")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be number: ${String(field)}`
+        );
+      const delta = tables.increment.by?.[i] ?? 1;
+      if (!Number.isFinite(delta))
+        throw new MachinaDispatchError("InvalidDispatchValue", "increment delta must be finite");
+      return { ...state, [field]: current + delta };
+    }
+  }
+  if (tables.setSuffix) {
+    validatePrefixSetTable(tables.setSuffix);
+    for (let i = 0; i < tables.setSuffix.prefixes.length; i += 1) {
+      const suffix = matchEventPrefix(
+        event,
+        tables.setSuffix.prefixes[i],
+        tables.setSuffix.allowedSuffixes?.[i]
+      );
+      if (suffix === void 0) continue;
+      const field = tables.setSuffix.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      if (Object.is(base[field], suffix)) return state;
+      return { ...state, [field]: suffix };
+    }
+  }
+  if (tables.incrementSuffix) {
+    validatePrefixIncrementTable(tables.incrementSuffix);
+    for (let i = 0; i < tables.incrementSuffix.prefixes.length; i += 1) {
+      const suffix = matchEventPrefix(
+        event,
+        tables.incrementSuffix.prefixes[i],
+        tables.incrementSuffix.allowedSuffixes?.[i]
+      );
+      if (suffix === void 0) continue;
+      const field = tables.incrementSuffix.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "number")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be number: ${String(field)}`
+        );
+      const delta = tables.incrementSuffix.by?.[i] ?? 1;
+      if (!Number.isFinite(delta))
+        throw new MachinaDispatchError("InvalidDispatchValue", "increment delta must be finite");
+      return { ...state, [field]: current + delta };
+    }
+  }
+  return state;
+}
+export {
+  MachinaDispatchError,
+  defineDispatchTables,
+  dispatchEvent,
+  matchEventPrefix,
+  resolveEventValue
+};