@pixerate/editor 0.26.1 → 0.28.0

package/dist/commands/index.js

@@ -1,5 +1,17 @@
 import {
-  DEFAULT_ARRANGE_SHORTCUTS,
+  DEFAULT_HISTORY_SHORTCUTS,
+  createArrangeCommands,
+  createComponentCommands,
+  createHistoryCommands,
+  createShapeCommands,
+  createSpreadsheetCommands,
+  hasVariantCommands,
+  matchHistoryShortcut
+} from "../chunk-IB3ZHQAX.js";
+import {
+  validateJsonSchema
+} from "../chunk-ARRTP33I.js";
+import {
   PLATFORMS,
   ShortcutMap,
   chordToString,
@@ -17,9 +29,6 @@ import {
   shortcutCode,
   toShortcutBindings
 } from "../chunk-7DWMJCAT.js";
-import {
-  validateJsonSchema
-} from "../chunk-ARRTP33I.js";
 
 // src/commands/registry.ts
 var CommandRegistryError = class extends Error {
@@ -239,10 +248,10 @@ var CommandRegistry = class {
   }
   /** Like `execute`, but awaits async commands (rejections become `failed` results). */
   async executeAsync(id, params, context = this.context) {
-    const outcome2 = this.execute(id, params, context);
-    if (!outcome2.ok || !isThenable(outcome2.result)) return outcome2;
+    const outcome = this.execute(id, params, context);
+    if (!outcome.ok || !isThenable(outcome.result)) return outcome;
     try {
-      const result = await outcome2.result;
+      const result = await outcome.result;
       this.notify();
       return { ok: true, id, result };
     } catch (error) {
@@ -680,396 +689,6 @@ function createCommandToolProvider(registry, options = {}) {
   };
 }
 
-// src/commands/builtins.ts
-var DEFAULT_HISTORY_SHORTCUTS = [
-  { command: "undo", chord: "Mod+Z" },
-  { command: "redo", chord: "Mod+Shift+Z" },
-  { command: "redo", chord: "Mod+Y", platforms: ["windows", "linux"] }
-];
-function createHistoryCommands(history, options = {}) {
-  const prefix = options.prefix ?? "history.";
-  const group = options.group ?? "Edit";
-  const shortcutsOf = (command) => DEFAULT_HISTORY_SHORTCUTS.filter((b) => b.command === command).map(({ command: _c, ...rest }) => rest);
-  return [
-    {
-      id: `${prefix}undo`,
-      label: "Undo",
-      group,
-      keywords: ["revert", "back"],
-      description: "Reverts the last change.",
-      shortcut: shortcutsOf("undo"),
-      ...options.scope ? { scope: options.scope } : {},
-      enabled: () => history.getState().canUndo ? true : "Nothing to undo.",
-      run: () => {
-        history.undo();
-        return { undone: true, state: history.getState() };
-      }
-    },
-    {
-      id: `${prefix}redo`,
-      label: "Redo",
-      group,
-      keywords: ["repeat", "forward"],
-      description: "Re-applies the last undone change.",
-      shortcut: shortcutsOf("redo"),
-      ...options.scope ? { scope: options.scope } : {},
-      enabled: () => history.getState().canRedo ? true : "Nothing to redo.",
-      run: () => {
-        history.redo();
-        return { redone: true, state: history.getState() };
-      }
-    }
-  ];
-}
-var historyShortcutMap = null;
-function matchHistoryShortcut(event, options = {}) {
-  historyShortcutMap ??= new ShortcutMap(DEFAULT_HISTORY_SHORTCUTS);
-  return historyShortcutMap.resolve(event, options)?.command ?? null;
-}
-var ARRANGE_LABELS = {
-  alignLeft: "Align Left",
-  alignCenter: "Align Horizontal Centers",
-  alignRight: "Align Right",
-  alignTop: "Align Top",
-  alignMiddle: "Align Vertical Centers",
-  alignBottom: "Align Bottom",
-  distributeHorizontal: "Distribute Horizontally",
-  distributeVertical: "Distribute Vertically",
-  lock: "Lock",
-  unlock: "Unlock",
-  bringForward: "Bring Forward",
-  sendBackward: "Send Backward",
-  bringToFront: "Bring to Front",
-  sendToBack: "Send to Back",
-  nextScene: "Next Scene",
-  previousScene: "Previous Scene"
-};
-var IDS_PARAMS = {
-  type: "object",
-  properties: {
-    ids: {
-      type: "array",
-      items: { type: "string" },
-      description: "Node ids to act on (default: the selection)."
-    }
-  }
-};
-function createArrangeCommands(controller, options = {}) {
-  const prefix = options.prefix ?? "canvas.";
-  const group = options.group ?? "Arrange";
-  const scope = options.scope === null ? void 0 : options.scope ?? "canvas";
-  const bindings = options.bindings ?? DEFAULT_ARRANGE_SHORTCUTS;
-  const count = (params) => params?.ids?.length ?? options.getSelectedIds?.().length;
-  const needs = (min, what) => (_, params) => {
-    const n = count(params);
-    if (n === void 0 || n >= min) return true;
-    return min === 1 ? `Select a ${what} first.` : `Select at least ${min} ${what}s.`;
-  };
-  const run = {
-    alignLeft: (ids) => controller.align("left", ids),
-    alignCenter: (ids) => controller.align("center", ids),
-    alignRight: (ids) => controller.align("right", ids),
-    alignTop: (ids) => controller.align("top", ids),
-    alignMiddle: (ids) => controller.align("middle", ids),
-    alignBottom: (ids) => controller.align("bottom", ids),
-    distributeHorizontal: (ids) => controller.distribute("horizontal", "gaps", ids),
-    distributeVertical: (ids) => controller.distribute("vertical", "gaps", ids),
-    lock: (ids) => controller.lock(ids),
-    unlock: (ids) => controller.unlock(ids),
-    bringForward: (ids) => controller.reorder("bringForward", ids),
-    sendBackward: (ids) => controller.reorder("sendBackward", ids),
-    bringToFront: (ids) => controller.reorder("bringToFront", ids),
-    sendToBack: (ids) => controller.reorder("sendToBack", ids),
-    nextScene: () => options.scenes?.next(),
-    previousScene: () => options.scenes?.previous()
-  };
-  const actions = Object.keys(ARRANGE_LABELS);
-  return actions.filter((action) => options.scenes || action !== "nextScene" && action !== "previousScene").map((action) => {
-    const isScene = action === "nextScene" || action === "previousScene";
-    const enabled = isScene ? void 0 : action.startsWith("align") ? needs(2, "node") : action.startsWith("distribute") ? needs(3, "node") : needs(1, "node");
-    return {
-      id: `${prefix}${action}`,
-      label: ARRANGE_LABELS[action],
-      group: isScene ? "Scenes" : group,
-      keywords: isScene ? ["scene", "slide", "page"] : action.startsWith("align") ? ["align"] : ["arrange", "layer", "order"],
-      ...scope ? { scope } : {},
-      shortcut: bindings.filter((b) => b.action === action).map((b) => b.label),
-      ...isScene ? {} : { params: IDS_PARAMS },
-      ...enabled ? { enabled } : {},
-      run: (_ctx, params) => run[action](params?.ids)
-    };
-  });
-}
-var SHAPE_COMMANDS = [
-  { op: "unite", label: "Unite Shapes", keywords: ["union", "merge", "boolean", "combine"] },
-  { op: "intersect", label: "Intersect Shapes", keywords: ["intersection", "boolean", "combine"] },
-  { op: "subtract", label: "Subtract Shapes", keywords: ["difference", "minus front", "boolean", "combine"] },
-  { op: "exclude", label: "Exclude Shapes", keywords: ["xor", "boolean", "combine"] },
-  { op: "divide", label: "Divide Shapes", keywords: ["split", "pathfinder", "boolean"] }
-];
-var JOIN_PARAM = { type: "string", enum: ["miter", "round", "bevel"], description: "Corner style (default miter)." };
-function createShapeCommands(controller, options = {}) {
-  const prefix = options.prefix ?? "canvas.";
-  const group = options.group ?? "Shape";
-  const scope = options.scope === null ? void 0 : options.scope ?? "canvas";
-  const base = { group, ...scope ? { scope } : {} };
-  const combine = SHAPE_COMMANDS.map(
-    ({ op, label, keywords }) => ({
-      ...base,
-      id: `${prefix}${op}`,
-      label,
-      keywords: [...keywords],
-      description: `${label.split(" ")[0]}s the selected shapes into a new path (curves are kept).`,
-      params: IDS_PARAMS,
-      enabled: (_ctx, params) => controller.canCombineShapes(params?.ids) ? true : "Select at least two unlocked shapes.",
-      run: (_ctx, params) => controller.combineShapes(op, params?.ids)
-    })
-  );
-  return [
-    ...combine,
-    {
-      ...base,
-      id: `${prefix}offsetPath`,
-      label: "Offset Path\u2026",
-      keywords: ["inset", "outset", "grow", "shrink", "expand", "contract"],
-      description: "Grows (positive distance) or shrinks (negative) the selected shapes.",
-      params: {
-        type: "object",
-        properties: {
-          distance: { type: "number", description: `Offset in canvas units (default ${options.defaultOffset ?? 10}).` },
-          join: JOIN_PARAM,
-          miterLimit: { type: "number", description: "Miter limit (default 4)." },
-          ids: IDS_PARAMS.properties.ids
-        }
-      },
-      enabled: (_ctx, params) => controller.canOffsetShapes(params?.ids) ? true : "Select an unlocked shape.",
-      run: (_ctx, params) => controller.offsetShapes(params?.distance ?? options.defaultOffset ?? 10, params?.ids, {
-        ...params?.join ? { join: params.join } : {},
-        ...params?.miterLimit !== void 0 ? { miterLimit: params.miterLimit } : {}
-      })
-    },
-    {
-      ...base,
-      id: `${prefix}outlineStroke`,
-      label: "Outline Stroke",
-      keywords: ["expand stroke", "stroke to path", "convert stroke"],
-      description: "Converts the strokes of the selected shapes to filled shapes.",
-      params: {
-        type: "object",
-        properties: {
-          join: JOIN_PARAM,
-          cap: { type: "string", enum: ["butt", "round", "square"], description: "Line cap (default butt)." },
-          miterLimit: { type: "number", description: "Miter limit (default 4)." },
-          ids: IDS_PARAMS.properties.ids
-        }
-      },
-      enabled: (_ctx, params) => controller.canOutlineStroke(params?.ids) ? true : "Select an unlocked shape with a stroke.",
-      run: (_ctx, params) => controller.outlineStroke(params?.ids, {
-        ...params?.join ? { join: params.join } : {},
-        ...params?.cap ? { cap: params.cap } : {},
-        ...params?.miterLimit !== void 0 ? { miterLimit: params.miterLimit } : {}
-      })
-    }
-  ];
-}
-var outcome = (result) => {
-  if (!result.ok) throw new Error(result.reason);
-  return { ids: result.ids };
-};
-var ID_PARAM = { type: "string", description: "Instance (or layer inside one) to act on (default: the first selected node)." };
-function createComponentCommands(controller, options = {}) {
-  const prefix = options.prefix ?? "canvas.";
-  const group = options.group ?? "Components";
-  const scope = options.scope === null ? void 0 : options.scope ?? "canvas";
-  const base = { group, ...scope ? { scope } : {} };
-  const idParams = { type: "object", properties: { id: ID_PARAM } };
-  return [
-    {
-      ...base,
-      id: `${prefix}createComponent`,
-      label: "Create Component",
-      keywords: ["component", "symbol", "main component", "reusable"],
-      description: "Turns the selected frame into a main component, or wraps the selection in one.",
-      params: IDS_PARAMS,
-      shortcut: "Mod+Alt+K",
-      enabled: (_ctx, params) => controller.canCreateComponent(params?.ids),
-      run: (_ctx, params) => outcome(controller.createComponent(params?.ids))
-    },
-    {
-      ...base,
-      id: `${prefix}combineAsVariants`,
-      label: "Combine as Variants",
-      keywords: ["component set", "variant", "variants"],
-      description: "Wraps the selected components in a component set.",
-      params: IDS_PARAMS,
-      enabled: (_ctx, params) => controller.canCombineAsVariants(params?.ids),
-      run: (_ctx, params) => outcome(controller.combineAsVariants(params?.ids))
-    },
-    {
-      ...base,
-      id: `${prefix}createInstance`,
-      label: "Create Instance",
-      keywords: ["instance", "insert component", "use component"],
-      description: "Places an instance of a component (or a component set\u2019s default variant).",
-      params: {
-        type: "object",
-        properties: {
-          componentId: { type: "string", description: "Component or component set id." },
-          parentId: { type: "string", description: "Frame to place it in (default: the canvas)." },
-          x: { type: "number", description: "X in the parent\u2019s space (default: next to the main)." },
-          y: { type: "number", description: "Y in the parent\u2019s space." },
-          properties: { type: "object", description: "Variant and component property values.", additionalProperties: true }
-        },
-        required: ["componentId"]
-      },
-      enabled: (_ctx, params) => params?.componentId === void 0 ? true : controller.canCreateInstance(params.componentId, params.parentId),
-      run: (_ctx, params) => outcome(
-        controller.createInstance(params.componentId, {
-          ...params.parentId !== void 0 ? { parentId: params.parentId } : {},
-          ...params.x !== void 0 || params.y !== void 0 ? { position: { x: params.x ?? 0, y: params.y ?? 0 } } : {},
-          ...params.properties ? { properties: params.properties } : {}
-        })
-      )
-    },
-    {
-      ...base,
-      id: `${prefix}detachInstance`,
-      label: "Detach Instance",
-      keywords: ["unlink", "break instance"],
-      description: "Turns the selected instances into plain frames that keep their look.",
-      params: IDS_PARAMS,
-      shortcut: "Mod+Alt+B",
-      enabled: (_ctx, params) => controller.canDetachInstance(params?.ids),
-      run: (_ctx, params) => outcome(controller.detachInstance(params?.ids))
-    },
-    {
-      ...base,
-      id: `${prefix}resetOverrides`,
-      label: "Reset All Changes",
-      keywords: ["reset instance", "reset overrides", "revert"],
-      description: "Resets the overrides of an instance (or of a layer, or one override group) to its main.",
-      params: {
-        type: "object",
-        properties: {
-          id: ID_PARAM,
-          group: { type: "string", description: 'One override group to reset, e.g. "data.label" or "shape.fill" (default: all).' }
-        }
-      },
-      enabled: (_ctx, params) => controller.canResetOverrides(params?.id),
-      run: (_ctx, params) => outcome(controller.resetOverrides(params?.id, params?.group))
-    },
-    {
-      ...base,
-      id: `${prefix}pushOverrides`,
-      label: "Push Changes to Main Component",
-      keywords: ["push overrides", "update main component"],
-      description: "Copies the instance\u2019s overrides to its main component and every other instance.",
-      params: idParams,
-      enabled: (_ctx, params) => controller.canPushOverrides(params?.id),
-      run: (_ctx, params) => outcome(controller.pushOverrides(params?.id))
-    },
-    {
-      ...base,
-      id: `${prefix}goToMainComponent`,
-      label: "Go to Main Component",
-      keywords: ["main component", "find main", "reveal"],
-      description: "Selects the main component of the selected instance.",
-      params: idParams,
-      enabled: (_ctx, params) => controller.canGoToMainComponent(params?.id),
-      run: (_ctx, params) => {
-        const main = controller.goToMainComponent(params?.id);
-        if (!main) throw new Error("The main component was not found.");
-        return { id: main };
-      }
-    },
-    {
-      ...base,
-      id: `${prefix}swapInstance`,
-      label: "Swap Instance\u2026",
-      keywords: ["replace instance", "swap component"],
-      description: "Makes the selected instances show another component, keeping matching overrides.",
-      params: {
-        type: "object",
-        properties: {
-          componentId: { type: "string", description: "Component or component set to swap to." },
-          ids: IDS_PARAMS.properties.ids
-        },
-        required: ["componentId"]
-      },
-      enabled: (_ctx, params) => controller.canSwapInstance(params?.componentId, params?.ids),
-      run: (_ctx, params) => outcome(controller.swapInstance(params.componentId, params?.ids))
-    },
-    {
-      ...base,
-      id: `${prefix}setInstanceProperties`,
-      label: "Set Instance Properties\u2026",
-      keywords: ["variant", "switch variant", "component property", "toggle"],
-      description: "Sets variant properties (switching variants) and component property values of the selected instances.",
-      params: {
-        type: "object",
-        properties: {
-          properties: { type: "object", description: "Property name \u2192 value (variant value, boolean, text or component id).", additionalProperties: true },
-          ids: IDS_PARAMS.properties.ids
-        },
-        required: ["properties"]
-      },
-      enabled: (_ctx, params) => controller.canSetInstanceProperties(params?.ids),
-      run: (_ctx, params) => outcome(controller.setInstanceProperties(params.properties, params?.ids))
-    },
-    {
-      ...base,
-      id: `${prefix}restoreMainComponent`,
-      label: "Restore Main Component",
-      keywords: ["missing main", "recover component"],
-      description: "Turns an instance whose main was deleted back into the main component.",
-      params: idParams,
-      enabled: (_ctx, params) => controller.canRestoreMainComponent(params?.id),
-      run: (_ctx, params) => outcome(controller.restoreMainComponent(params?.id))
-    },
-    {
-      ...base,
-      id: `${prefix}listComponents`,
-      label: "List Components",
-      keywords: ["components", "variants", "assets"],
-      description: "Lists the components and component sets (with their variant options).",
-      readOnly: true,
-      run: () => controller.list()
-    },
-    {
-      ...base,
-      id: `${prefix}inspectInstance`,
-      label: "Inspect Instance",
-      keywords: ["instance", "overrides", "properties"],
-      description: "Describes an instance: its main, variant, property values and overrides.",
-      params: idParams,
-      readOnly: true,
-      enabled: (_ctx, params) => controller.inspect(params?.id) ? true : "Select an instance.",
-      run: (_ctx, params) => controller.inspect(params?.id) ?? null
-    }
-  ];
-}
-function createSpreadsheetCommands(controller, options = {}) {
-  const prefix = options.prefix ?? "spreadsheet.";
-  const scope = options.scope === null ? void 0 : options.scope ?? "spreadsheet";
-  const hasRange = () => controller.selectedRange ? true : "Select a range first.";
-  const base = { group: "Table", ...scope ? { scope } : {} };
-  return [
-    { ...base, id: `${prefix}toggleFilters`, label: "Toggle Filters", keywords: ["filter"], run: () => controller.toggleFilters() },
-    {
-      ...base,
-      id: `${prefix}clearFilters`,
-      label: "Clear Filters",
-      keywords: ["filter", "reset"],
-      enabled: () => controller.getFilterState().rules.length > 0 ? true : "No filters to clear.",
-      run: () => controller.clearFilters()
-    },
-    { ...base, id: `${prefix}unhideAll`, label: "Unhide All Rows and Columns", keywords: ["show", "hidden"], run: () => controller.unhideAll() },
-    { ...base, id: `${prefix}mergeCells`, label: "Merge Cells", keywords: ["combine"], enabled: hasRange, run: () => controller.mergeCells() },
-    { ...base, id: `${prefix}unmergeCells`, label: "Unmerge Cells", keywords: ["split"], enabled: hasRange, run: () => controller.unmergeCells() },
-    { ...base, id: `${prefix}transposeRange`, label: "Transpose Range", keywords: ["rotate", "swap rows columns"], enabled: hasRange, run: () => controller.transposeRange() }
-  ];
-}
-
 // src/commands/animation.ts
 var EASING_DESCRIPTION = "Easing preset (linear, ease, ease-in, ease-out, ease-in-out, ease-in-back, ease-out-back, spring, hold) or a CSS cubic-bezier(x1, y1, x2, y2).";
 var VALUES = {
@@ -1267,6 +886,7 @@ export {
   formatShortcut,
   fuzzyMatch,
   fuzzyScore,
+  hasVariantCommands,
   isEditableEventTarget,
   keyToCode,
   matchHistoryShortcut,