@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/canvas-edit.ts

@@ -3598,12 +3598,16 @@ export async function setArtboardHug(
 }
 
 /** Patch shape for {@link applySetArtboardStyle} — `null` resets/removes that
- *  prop back to the engine default; `undefined`/absent leaves it untouched. */
+ *  prop back to the engine default; `undefined`/absent leaves it untouched.
+ *  padding/gap accept a `var(--token)` STRING alongside raw px numbers
+ *  (dogfood: the Inspector's artboard panel binds space tokens the same way
+ *  the CSS panel's ValueTokenField does) — validation of the string shape
+ *  lives at the api.ts layer, same split as every other artboard writer. */
 export interface ArtboardStylePatch {
   background?: string | null;
-  padding?: number | null;
+  padding?: number | string | null;
   layout?: string | null;
-  gap?: number | null;
+  gap?: number | string | null;
 }
 
 /**
@@ -3647,10 +3651,14 @@ export function applySetArtboardStyle(
   }
   if ('padding' in patch) {
     if (patch.padding == null) removeStringAttr(s, opening, 'padding', source);
+    else if (typeof patch.padding === 'string')
+      editStringAttr(s, opening, 'padding', patch.padding, canvasAbsPath, artboardId);
     else writeNumericAttr(s, opening, 'padding', patch.padding, 0);
   }
   if ('gap' in patch) {
     if (patch.gap == null) removeStringAttr(s, opening, 'gap', source);
+    else if (typeof patch.gap === 'string')
+      editStringAttr(s, opening, 'gap', patch.gap, canvasAbsPath, artboardId);
     else writeNumericAttr(s, opening, 'gap', patch.gap, 0);
   }
   const out = s.toString();
@@ -3689,6 +3697,297 @@ export async function setArtboardStyle(
   });
 }
 
+const ARTBOARD_KIND_VALUES = new Set(['digital', 'print', 'web', 'video']);
+
+/**
+ * Write/clear the DCArtboard `kind` prop (feature-1-artboard-kinds-foundation
+ * T5/T8) — kind-switch surfaces (context menu, Inspector) route here. Plain
+ * string prop, so this reuses the same `editStringAttr`/`removeStringAttr`
+ * toolkit + id-prop addressing as `applySetArtboardStyle`. `kind: null` clears
+ * back to the implicit default (`digital`, or the `subtreeHasVideoComp`
+ * fallback). Pure; reparse-gated.
+ */
+export function applySetArtboardKind(
+  canvasAbsPath: string,
+  source: string,
+  artboardId: string,
+  kind: string | null
+): { source: string } {
+  if (kind !== null && !ARTBOARD_KIND_VALUES.has(kind)) {
+    throw new CanvasEditError(`invalid artboard kind "${kind}"`, {
+      canvas: canvasAbsPath,
+      id: artboardId,
+    });
+  }
+  const parsed = parseSync(canvasAbsPath, source, { sourceType: 'module' });
+  if (parsed.errors && parsed.errors.length > 0) {
+    throw new CanvasEditError(
+      `oxc-parser failed on ${canvasAbsPath}: ${parsed.errors[0]?.message ?? 'unknown'}`,
+      { canvas: canvasAbsPath, id: artboardId }
+    );
+  }
+  const artboards = collectJsxByTag(parsed.program, 'DCArtboard');
+  const target = artboards.find((a) => getStringAttr(a.openingElement, 'id') === artboardId);
+  if (!target) {
+    throw new CanvasEditError(`<DCArtboard id="${artboardId}"> not found in ${canvasAbsPath}`, {
+      canvas: canvasAbsPath,
+      id: artboardId,
+    });
+  }
+  const s = new MagicString(source);
+  const opening = target.openingElement;
+  if (kind === null) removeStringAttr(s, opening, 'kind', source);
+  else editStringAttr(s, opening, 'kind', kind, canvasAbsPath, artboardId);
+  const out = s.toString();
+  const check = parseSync(canvasAbsPath, out, { sourceType: 'module' });
+  if (check.errors && check.errors.length > 0) {
+    throw new CanvasEditError(
+      `artboard kind edit produced invalid source (${check.errors[0]?.message ?? 'parse error'})`,
+      { canvas: canvasAbsPath, id: artboardId }
+    );
+  }
+  return { source: out };
+}
+
+/** Set an artboard's `kind` on disk (atomic write + cross-process lock). */
+export async function setArtboardKind(
+  canvasAbsPath: string,
+  artboardId: string,
+  kind: string | null
+): Promise<{ source: string }> {
+  return withLock(canvasAbsPath, async () => {
+    const file = Bun.file(canvasAbsPath);
+    if (!(await file.exists())) {
+      throw new CanvasEditError(`Canvas not found: ${canvasAbsPath}`, {
+        canvas: canvasAbsPath,
+        id: artboardId,
+      });
+    }
+    const source = await file.text();
+    const next = applySetArtboardKind(canvasAbsPath, source, artboardId, kind);
+    if (next.source === source) return next;
+    const tmp = `${canvasAbsPath}.tmp.${Math.random().toString(36).slice(2, 10)}`;
+    await Bun.write(tmp, next.source);
+    const { rename } = await import('node:fs/promises');
+    await rename(tmp, canvasAbsPath);
+    return next;
+  });
+}
+
+/**
+ * Write/clear an object-VALUED DCArtboard prop (`guides={{ columns: {...} }}`,
+ * `print={{ paper: 'a4' }}`), unlike every other artboard writer above.
+ * Per the plan's own gotcha, object-prop editing via AST is the hard part;
+ * this scopes to REPLACE-WHOLE-PROP (stringify the given object and overwrite
+ * the entire `{{...}}` span), not a deep merge — a caller that wants to keep
+ * one key while adding another must read the current value back (Inspector
+ * pre-fill reads `data-dc-*`-style attrs same as every other artboard knob)
+ * and send the full merged object. `value: null` removes the prop entirely.
+ * `JSON.stringify` output is valid as a JS object-literal expression (quoted
+ * keys are legal JS, not just JSON), so no separate JS-literal serializer is
+ * needed. Shape validation lives at the api.ts layer; this is pure AST
+ * surgery. Pure; reparse-gated. Shared by `applySetArtboardGuides` and
+ * `applySetArtboardPrint` (feature-2-print-artboards T2) below.
+ */
+function applySetArtboardObjectProp(
+  canvasAbsPath: string,
+  source: string,
+  artboardId: string,
+  propName: string,
+  value: Record<string, unknown> | null
+): { source: string } {
+  const parsed = parseSync(canvasAbsPath, source, { sourceType: 'module' });
+  if (parsed.errors && parsed.errors.length > 0) {
+    throw new CanvasEditError(
+      `oxc-parser failed on ${canvasAbsPath}: ${parsed.errors[0]?.message ?? 'unknown'}`,
+      { canvas: canvasAbsPath, id: artboardId }
+    );
+  }
+  const artboards = collectJsxByTag(parsed.program, 'DCArtboard');
+  const target = artboards.find((a) => getStringAttr(a.openingElement, 'id') === artboardId);
+  if (!target) {
+    throw new CanvasEditError(`<DCArtboard id="${artboardId}"> not found in ${canvasAbsPath}`, {
+      canvas: canvasAbsPath,
+      id: artboardId,
+    });
+  }
+  const s = new MagicString(source);
+  const opening = target.openingElement;
+  if (value === null) {
+    removeStringAttr(s, opening, propName, source);
+  } else {
+    const literal = JSON.stringify(value);
+    const attr = findAttribute(opening, propName);
+    if (!attr) {
+      const insertAt: number | undefined = opening?.name?.end;
+      if (typeof insertAt !== 'number') {
+        throw new Error('Opening element has no resolvable name range');
+      }
+      s.appendLeft(insertAt, ` ${propName}={${literal}}`);
+    } else if (attr.value?.type === 'JSXExpressionContainer') {
+      s.overwrite(attr.value.start, attr.value.end, `{${literal}}`);
+    } else {
+      throw new CanvasEditError(
+        `${propName} attribute is not a {{...}} expression — refusing to edit`,
+        {
+          canvas: canvasAbsPath,
+          id: artboardId,
+        }
+      );
+    }
+  }
+  const out = s.toString();
+  const check = parseSync(canvasAbsPath, out, { sourceType: 'module' });
+  if (check.errors && check.errors.length > 0) {
+    throw new CanvasEditError(
+      `artboard ${propName} edit produced invalid source (${check.errors[0]?.message ?? 'parse error'})`,
+      { canvas: canvasAbsPath, id: artboardId }
+    );
+  }
+  return { source: out };
+}
+
+/** Set an artboard's object-valued prop on disk (atomic write + cross-process lock). */
+async function setArtboardObjectProp(
+  canvasAbsPath: string,
+  artboardId: string,
+  propName: string,
+  value: Record<string, unknown> | null
+): Promise<{ source: string }> {
+  return withLock(canvasAbsPath, async () => {
+    const file = Bun.file(canvasAbsPath);
+    if (!(await file.exists())) {
+      throw new CanvasEditError(`Canvas not found: ${canvasAbsPath}`, {
+        canvas: canvasAbsPath,
+        id: artboardId,
+      });
+    }
+    const source = await file.text();
+    const next = applySetArtboardObjectProp(canvasAbsPath, source, artboardId, propName, value);
+    if (next.source === source) return next;
+    const tmp = `${canvasAbsPath}.tmp.${Math.random().toString(36).slice(2, 10)}`;
+    await Bun.write(tmp, next.source);
+    const { rename } = await import('node:fs/promises');
+    await rename(tmp, canvasAbsPath);
+    return next;
+  });
+}
+
+export function applySetArtboardGuides(
+  canvasAbsPath: string,
+  source: string,
+  artboardId: string,
+  guides: Record<string, unknown> | null
+): { source: string } {
+  return applySetArtboardObjectProp(canvasAbsPath, source, artboardId, 'guides', guides);
+}
+
+/** Set an artboard's `guides` on disk (atomic write + cross-process lock). */
+export function setArtboardGuides(
+  canvasAbsPath: string,
+  artboardId: string,
+  guides: Record<string, unknown> | null
+): Promise<{ source: string }> {
+  return setArtboardObjectProp(canvasAbsPath, artboardId, 'guides', guides);
+}
+
+/**
+ * Write/clear the DCArtboard `print` prop (feature-2-print-artboards T2) —
+ * see `applySetArtboardObjectProp`'s doc comment for the shared shape.
+ * `print: null` removes the prop entirely (e.g. reverting an artboard to a
+ * non-print kind).
+ */
+export function applySetArtboardPrint(
+  canvasAbsPath: string,
+  source: string,
+  artboardId: string,
+  print: Record<string, unknown> | null
+): { source: string } {
+  return applySetArtboardObjectProp(canvasAbsPath, source, artboardId, 'print', print);
+}
+
+/** Set an artboard's `print` on disk (atomic write + cross-process lock). */
+export function setArtboardPrint(
+  canvasAbsPath: string,
+  artboardId: string,
+  print: Record<string, unknown> | null
+): Promise<{ source: string }> {
+  return setArtboardObjectProp(canvasAbsPath, artboardId, 'print', print);
+}
+
+/**
+ * Read a JS object-literal AST node into a plain object WITHOUT eval —
+ * `print` (like every other canvas-authored JSX prop) is part of the
+ * DDR-054 untrusted-canvas surface, so evaluating its source text
+ * (`Function('return ' + src)()`) would be a code-injection hole. Handles
+ * string/numeric/boolean/null literals and nested object literals; any other
+ * value shape (identifiers, calls, template strings, arrays) is silently
+ * skipped — conservative by design, since a print-geometry reader should
+ * degrade to "field absent" rather than guess. Depth-capped defensively,
+ * though `print`'s own shape never nests past marginsMm (depth 2).
+ */
+function objectExpressionToPlain(node: AnyNode, depth = 0): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (depth > 6 || node?.type !== 'ObjectExpression') return out;
+  for (const p of node.properties ?? []) {
+    if ((p?.type !== 'Property' && p?.type !== 'ObjectProperty') || p.computed) continue;
+    const key =
+      p.key?.type === 'Identifier'
+        ? (p.key.name as string)
+        : isStringLit(p.key)
+          ? String(p.key.value)
+          : null;
+    if (key === null) continue;
+    const v = p.value;
+    if (!v) continue;
+    if (v.type === 'ObjectExpression') {
+      out[key] = objectExpressionToPlain(v, depth + 1);
+    } else if (
+      (v.type === 'Literal' ||
+        v.type === 'StringLiteral' ||
+        v.type === 'NumericLiteral' ||
+        v.type === 'BooleanLiteral') &&
+      (typeof v.value === 'string' ||
+        typeof v.value === 'number' ||
+        typeof v.value === 'boolean' ||
+        v.value === null)
+    ) {
+      out[key] = v.value;
+    }
+    // else: unsupported value shape — key silently omitted.
+  }
+  return out;
+}
+
+/**
+ * Read an artboard's `print` JSX prop as a plain object — used by the PDF
+ * exporter (T5) to resolve bleed/paper geometry for the artboard being
+ * exported. Read-only (no lock, no write). Returns null when the canvas/
+ * artboard/prop doesn't exist, `print` isn't a `{{...}}` object-expression,
+ * or `kind` isn't the literal string `"print"` — a `print` prop left over
+ * from a prior kind switch (or hand-authored on a non-print artboard) must
+ * NOT leak bleed/marks into an export; `kind="print"` is the sole gate
+ * (unlike `video`, print has no implicit structural-fallback resolution, so
+ * checking the explicit attr is sufficient — see DDR-181/canvas-lib.tsx).
+ */
+export function readArtboardPrintProp(
+  canvasAbsPath: string,
+  source: string,
+  artboardId: string
+): Record<string, unknown> | null {
+  const parsed = parseSync(canvasAbsPath, source, { sourceType: 'module' });
+  if (parsed.errors && parsed.errors.length > 0) return null;
+  const artboards = collectJsxByTag(parsed.program, 'DCArtboard');
+  const target = artboards.find((a) => getStringAttr(a.openingElement, 'id') === artboardId);
+  if (!target) return null;
+  if (getStringAttr(target.openingElement, 'kind') !== 'print') return null;
+  const attr = findAttribute(target.openingElement, 'print');
+  if (attr?.value?.type !== 'JSXExpressionContainer') return null;
+  const expr = attr.value.expression as AnyNode | undefined;
+  if (expr?.type !== 'ObjectExpression') return null;
+  return objectExpressionToPlain(expr);
+}
+
 /**
  * Delete the `<DCArtboard id="…">` whose `id` prop equals `artboardId` — the
  * artboard counterpart of applyDeleteElement (an artboard is addressed by its id