@1agh/maude 0.41.0 → 0.43.0

package/apps/studio/commands/edit-source-command.ts

@@ -46,6 +46,14 @@ export interface EditSourcePayload {
   before: string | null;
   /** Value after the edit. `null` = the edit removed the prop/attr (the reset path). */
   after: string | null;
+  /**
+   * `op:'text'` only — which rendered instance this edit targeted (index among
+   * same-cd-id DOM nodes). Needed to re-apply a `{variable}` text edit through
+   * undo/redo: the engine traces the string back to the right `.map()` item or
+   * component-prop usage, and that resolution needs the occurrence. Undefined
+   * for literal text (the engine ignores it there) and for css/attr.
+   */
+  occurrence?: number;
 }
 
 /**
@@ -60,6 +68,14 @@ export type EditSourceApplyFn = (apply: {
   id: string;
   key: string;
   value: string | null;
+  /**
+   * `op:'text'` re-application only — the value CURRENTLY on disk (the side we
+   * replace FROM: `before` on redo, `after` on undo), so a `{variable}` edit
+   * can be traced to the right source string. Plus the occurrence. Ignored by
+   * css/attr and by literal-text edits.
+   */
+  from?: string | null;
+  occurrence?: number;
 }) => void | Promise<void>;
 
 export const EDIT_SOURCE_KIND = 'edit-source';
@@ -72,16 +88,27 @@ export interface EditSourceCommandInit {
 
 export function createEditSourceCommand(init: EditSourceCommandInit): EditCommand {
   const { payload, applyFn } = init;
-  const apply = (value: string | null) =>
-    applyFn({ op: payload.op, canvas: payload.canvas, id: payload.id, key: payload.key, value });
+  // `from` = the value on disk BEFORE this re-application (what a `{variable}`
+  // text resolver matches against). do() writes `after` over `before`; undo()
+  // writes `before` over `after`.
+  const apply = (value: string | null, from: string | null) =>
+    applyFn({
+      op: payload.op,
+      canvas: payload.canvas,
+      id: payload.id,
+      key: payload.key,
+      value,
+      from,
+      occurrence: payload.occurrence,
+    });
   return {
     kind: EDIT_SOURCE_KIND,
     label: init.label ?? defaultLabel(payload),
     async do() {
-      await apply(payload.after);
+      await apply(payload.after, payload.before);
     },
     async undo() {
-      await apply(payload.before);
+      await apply(payload.before, payload.after);
     },
   };
 }

package/apps/studio/config.schema.json

@@ -47,7 +47,7 @@
     "themeDefault": {
       "type": "string",
       "enum": ["dark", "light"],
-      "description": "Default theme attribute (data-theme) for new canvases.",
+      "description": "Default theme attribute (data-theme) for new canvases. Can only ever be a single theme name — it is NOT the signal for whether a DS ships more than one theme. For that, check 'designSystems[].themes'.",
       "default": "dark"
     },
     "tokensCssRel": {
@@ -187,7 +187,7 @@
           "themes": {
             "type": "array",
             "items": { "type": "string" },
-            "description": "Optional list of theme names this DS supports (used by the System view's theme toggle when more than one theme is declared)."
+            "description": "Authoritative list of theme names this DS's tokens CSS actually ships (e.g. ['dark','light']). This is the ONLY field that should be checked to decide whether a DS is dual-theme — 'themeDefault' can never hold 'both' (enum is dark|light only), so a single-theme entry MUST still list its one theme (e.g. ['dark']), not omit the field. Bootstrap/re-bootstrap always populates this from the theme-default discovery answer. Drives the System view's theme toggle, design-system-completeness-critic V18/V18c, and /design:new step 9's per-theme reality-check capture."
           },
           "newCanvasDir": {
             "type": "string",

package/apps/studio/context-menu.tsx

@@ -54,7 +54,12 @@ export interface MenuItem {
   /** Right-aligned shortcut hint (e.g. `⌘C`, `⌫`). */
   shortcut?: string;
   destructive?: boolean;
-  disabled?: boolean;
+  /**
+   * A FUNCTION form is resolved per-click against `target` — same rationale as
+   * the function-form `submenu` below (e.g. "Open Timeline" only enabled when
+   * THIS right-clicked artboard actually contains a video sequence).
+   */
+  disabled?: boolean | ((target: ContextTarget) => boolean);
   /**
    * Optional nested flyout (e.g. `Theme ▸ DS default / Light / Dark / Follow
    * chrome`). When present the row opens a submenu on hover / ArrowRight /
@@ -70,6 +75,13 @@ export interface MenuItem {
   submenu?: MenuItem[] | ((target: ContextTarget) => MenuItem[]);
   /** Hover/title hint shown when the item is `disabled` (a11y affordance). */
   disabledHint?: string;
+  /**
+   * Fully REMOVE the item for a target (vs. `disabled`, which greys it in place).
+   * Resolved per-click. Use when an entry is meaningless — not merely
+   * unavailable — for the right-clicked element (e.g. "Edit Photo…" only makes
+   * sense on an `<img>`, so it shouldn't appear at all on a `<div>`).
+   */
+  hidden?: boolean | ((target: ContextTarget) => boolean);
   onSelect: (target: ContextTarget) => void;
 }
 
@@ -371,9 +383,19 @@ export function ContextMenuView({
     };
   }, [target.clientX, target.clientY, onClose, pos.x, pos.y]);
 
+  // Resolve per-target `hidden` and drop now-empty sections (so a section that
+  // held only a hidden item doesn't leave a dangling separator).
+  const visibleSections = sections
+    .map((section) =>
+      section.filter((item) => {
+        const h = typeof item.hidden === 'function' ? item.hidden(target) : item.hidden;
+        return !h;
+      })
+    )
+    .filter((section) => section.length > 0);
   return (
     <div ref={ref} className="dc-context-menu" role="menu" style={{ left: pos.x, top: pos.y }}>
-      {sections.map((section, si) => {
+      {visibleSections.map((section, si) => {
         const sectionKey = section.map((i) => i.id).join('|') || `s${si}`;
         return (
           <div key={sectionKey} role="group">
@@ -411,17 +433,20 @@ function MenuItemRow({
   // Resolve a function-form submenu against THIS click's target (e.g.
   // "Select layer" computing candidates from `target.clientX/clientY`).
   const submenuItems = typeof item.submenu === 'function' ? item.submenu(target) : item.submenu;
+  // Same per-click resolution for a function-form `disabled` (e.g. "Open
+  // Timeline" only enabled on an artboard that actually contains video).
+  const disabled = typeof item.disabled === 'function' ? item.disabled(target) : item.disabled;
 
   if (!submenuItems || submenuItems.length === 0) {
     return (
       <button
         type="button"
         role="menuitem"
-        disabled={item.disabled}
-        title={item.disabled ? item.disabledHint : undefined}
+        disabled={disabled}
+        title={disabled ? item.disabledHint : undefined}
         className={`dc-menu-item${item.destructive ? ' is-destructive' : ''}`}
         onClick={() => {
-          if (item.disabled) return;
+          if (disabled) return;
           item.onSelect(target);
           onClose();
         }}
@@ -464,7 +489,7 @@ function MenuItemRow({
         role="menuitem"
         aria-haspopup="menu"
         aria-expanded={subOpen}
-        disabled={item.disabled}
+        disabled={disabled}
         className="dc-menu-item"
         onClick={() => (subOpen ? setSubOpen(false) : open())}
         onKeyDown={(e) => {