@dxos/app-framework 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/dist/lib/node-esm/chunk-URWHJQT2.mjs

@@ -0,0 +1,168 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  UndoOperation
+} from "./chunk-VKHGNEDB.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/plugin-operation/history/errors.ts
+import { BaseError } from "@dxos/errors";
+var EmptyHistoryError = class extends BaseError.extend("EmptyHistoryError", "Cannot undo: history is empty.") {
+};
+
+// src/plugin-operation/history/undo-mapping.ts
+var undo_mapping_exports = {};
+__export(undo_mapping_exports, {
+  make: () => make,
+  resolveMessage: () => resolveMessage
+});
+var make = (props) => props;
+var resolveMessage = (message, input, output) => {
+  if (message === void 0) {
+    return void 0;
+  }
+  if (typeof message === "function") {
+    return message(input, output);
+  }
+  return message;
+};
+
+// src/plugin-operation/history/undo-registry.ts
+var undo_registry_exports = {};
+__export(undo_registry_exports, {
+  make: () => make2
+});
+var make2 = (getMappings) => {
+  const lookup = (operation) => {
+    const mappings = getMappings();
+    const mapping = mappings.find((m) => m.operation.meta.key === operation.meta.key);
+    if (!mapping) {
+      return void 0;
+    }
+    return {
+      inverse: mapping.inverse,
+      deriveContext: mapping.deriveContext,
+      message: mapping.message
+    };
+  };
+  return {
+    lookup
+  };
+};
+
+// src/plugin-operation/history/history-tracker.ts
+var history_tracker_exports = {};
+__export(history_tracker_exports, {
+  make: () => make3
+});
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { runAndForwardErrors } from "@dxos/effect";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/plugin-operation/history/history-tracker.ts";
+var HISTORY_LIMIT = 100;
+var make3 = (invoker, undoRegistry) => {
+  const history = [];
+  const handleInvocation = (event) => {
+    const mapping = undoRegistry.lookup(event.operation);
+    if (!mapping) {
+      return;
+    }
+    const inverseInput = mapping.deriveContext(event.input, event.output);
+    if (inverseInput === void 0) {
+      log("operation not undoable", {
+        key: event.operation.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 57,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    const entry = {
+      operation: event.operation,
+      input: event.input,
+      output: event.output,
+      inverse: mapping.inverse,
+      inverseInput,
+      timestamp: event.timestamp
+    };
+    history.push(entry);
+    log("history entry added", {
+      key: event.operation.meta.key,
+      historyLength: history.length
+    }, {
+      F: __dxlog_file,
+      L: 71,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    if (history.length > HISTORY_LIMIT) {
+      history.splice(0, history.length - HISTORY_LIMIT);
+    }
+    const resolvedMessage = resolveMessage(mapping.message, event.input, event.output);
+    Effect.runFork(invoker.invoke(UndoOperation.ShowUndo, {
+      message: resolvedMessage
+    }));
+  };
+  Effect.runFork(Stream.fromPubSub(invoker.invocations).pipe(Stream.runForEach((event) => Effect.sync(() => handleInvocation(event)))));
+  const undo = () => {
+    return Effect.gen(function* () {
+      const entry = history.pop();
+      if (!entry) {
+        return yield* Effect.fail(new EmptyHistoryError());
+      }
+      log("undoing operation", {
+        key: entry.operation.meta.key,
+        inverseKey: entry.inverse.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 101,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* invoker._invokeCore(entry.inverse, entry.inverseInput);
+      log("undo completed", {
+        key: entry.operation.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 106,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  };
+  const undoPromise = async () => {
+    return runAndForwardErrors(undo()).then(() => ({})).catch((error) => {
+      log.catch(error, void 0, {
+        F: __dxlog_file,
+        L: 114,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return {
+        error
+      };
+    });
+  };
+  const canUndo = () => {
+    return history.length > 0;
+  };
+  return {
+    undo,
+    undoPromise,
+    canUndo
+  };
+};
+
+export {
+  EmptyHistoryError,
+  undo_mapping_exports,
+  make2 as make,
+  undo_registry_exports,
+  make3 as make2,
+  history_tracker_exports
+};
+//# sourceMappingURL=chunk-URWHJQT2.mjs.map

package/dist/lib/node-esm/chunk-URWHJQT2.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/plugin-operation/history/errors.ts", "../../../src/plugin-operation/history/undo-mapping.ts", "../../../src/plugin-operation/history/undo-registry.ts", "../../../src/plugin-operation/history/history-tracker.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError } from '@dxos/errors';\n\nexport class EmptyHistoryError extends BaseError.extend('EmptyHistoryError', 'Cannot undo: history is empty.') {}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/operation';\n\n/**\n * Label type for translatable text (canonical definition in @dxos/app-toolkit).\n */\ntype Label = string | [string, { ns: string; count?: number; defaultValue?: string }];\n\n/**\n * Extract the input type from an OperationDefinition.\n */\nexport type InputOf<T> = T extends Operation.Definition<infer I, any> ? I : never;\n\n/**\n * Extract the output type from an OperationDefinition.\n */\nexport type OutputOf<T> = T extends Operation.Definition<any, infer O> ? O : never;\n\n/**\n * Message provider for undo toast.\n * Can be a static Label or a function that derives the message from input/output.\n */\nexport type MessageProvider<Op extends Operation.Definition<any, any>> =\n  | Label\n  | ((input: InputOf<Op>, output: OutputOf<Op>) => Label);\n\n/**\n * Undo mapping that links a forward operation to its inverse.\n * Type parameters ensure deriveContext has correctly typed arguments.\n *\n * @template Op - The forward operation definition type.\n * @template Inv - The inverse operation definition type.\n */\nexport interface UndoMapping<\n  Op extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  readonly operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  readonly inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * @param input - The input that was passed to the forward operation.\n   * @param output - The output that was returned by the forward operation.\n   * @returns The input to pass to the inverse operation, or undefined to indicate the operation is not undoable.\n   */\n  readonly deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  readonly message?: MessageProvider<Op>;\n}\n\n/**\n * Props for creating an UndoMapping.\n */\nexport interface UndoMappingProps<\n  Op extends Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * Return undefined to indicate the operation is not undoable.\n   */\n  deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  message?: MessageProvider<Op>;\n}\n\n/**\n * Creates a type-safe undo mapping.\n *\n * @example\n * ```ts\n * // Static message\n * const mapping = UndoMapping.make({\n *   operation: DeleteThread,\n *   inverse: RestoreThread,\n *   deriveContext: (input, output) => ({\n *     thread: output.thread,\n *     anchor: output.anchor,\n *   }),\n *   message: ['thread deleted label', { ns: '@dxos/plugin-thread' }],\n * });\n *\n * // Dynamic message based on input/output\n * const mapping = UndoMapping.make({\n *   operation: RemoveObjects,\n *   inverse: RestoreObjects,\n *   deriveContext: (_input, output) => output,\n *   message: (input, _output) =>\n *     input.objects.length === 1\n *       ? ['object deleted label', { ns: getTypename(input.objects[0]) }]\n *       : ['objects deleted label', { ns: '@dxos/plugin-space' }],\n * });\n * ```\n */\nexport const make = <Op extends Operation.Definition<any, any>, Inv extends Operation.Definition<any, any>>(\n  props: UndoMappingProps<Op, Inv>,\n): UndoMapping<Op, Inv> => props;\n\n/**\n * Resolves a message provider to a Label.\n */\nexport const resolveMessage = <Op extends Operation.Definition<any, any>>(\n  message: MessageProvider<Op> | undefined,\n  input: InputOf<Op>,\n  output: OutputOf<Op>,\n): Label | undefined => {\n  if (message === undefined) {\n    return undefined;\n  }\n  if (typeof message === 'function') {\n    return message(input, output);\n  }\n  return message;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/operation';\n\nimport type * as UndoMapping from './undo-mapping';\n\n//\n// Public Interface\n//\n\n/**\n * Lookup result from UndoRegistry.\n */\nexport type UndoMappingResult = {\n  inverse: Operation.Definition<any, any>;\n  /** Returns undefined to indicate the operation is not undoable. */\n  deriveContext: (input: any, output: any) => any | undefined;\n  /** Message provider - may be a static Label or a function. */\n  message?: UndoMapping.MessageProvider<Operation.Definition<any, any>>;\n};\n\n/**\n * UndoRegistry interface - looks up inverse operations.\n */\nexport interface UndoRegistry {\n  lookup: (operation: Operation.Definition<any, any>) => UndoMappingResult | undefined;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates an UndoRegistry that looks up inverse operations.\n */\nexport const make = (getMappings: () => UndoMapping.UndoMapping[]): UndoRegistry => {\n  const lookup = (operation: Operation.Definition<any, any>): UndoMappingResult | undefined => {\n    const mappings = getMappings();\n    const mapping = mappings.find((m) => m.operation.meta.key === operation.meta.key);\n    if (!mapping) {\n      return undefined;\n    }\n\n    return {\n      inverse: mapping.inverse,\n      deriveContext: mapping.deriveContext,\n      message: mapping.message,\n    };\n  };\n\n  return { lookup };\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Stream from 'effect/Stream';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { log } from '@dxos/log';\nimport { type OperationInvoker } from '@dxos/operation';\n\nimport { UndoOperation } from '../../common';\nimport { EmptyHistoryError } from './errors';\nimport type { HistoryEntry } from './types';\nimport { resolveMessage } from './undo-mapping';\nimport type { UndoRegistry } from './undo-registry';\n\nconst HISTORY_LIMIT = 100;\n\n//\n// Public Interface\n//\n\n/**\n * HistoryTracker interface - tracks operation history and provides undo.\n */\nexport interface HistoryTracker {\n  undo: () => Effect.Effect<void, Error>;\n  undoPromise: () => Promise<{ error?: Error }>;\n  canUndo: () => boolean;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a HistoryTracker that subscribes to invocation events and provides undo.\n */\nexport const make = (\n  invoker: OperationInvoker.OperationInvokerInternal,\n  undoRegistry: UndoRegistry,\n): HistoryTracker => {\n  const history: HistoryEntry[] = [];\n\n  // Subscribe to invocation stream.\n  const handleInvocation = (event: OperationInvoker.InvocationEvent) => {\n    const mapping = undoRegistry.lookup(event.operation);\n    if (!mapping) {\n      // Operation is not undoable, skip.\n      return;\n    }\n\n    const inverseInput = mapping.deriveContext(event.input, event.output);\n    if (inverseInput === undefined) {\n      // Operation is conditionally not undoable (deriveContext returned undefined).\n      log('operation not undoable', { key: event.operation.meta.key });\n      return;\n    }\n\n    const entry: HistoryEntry = {\n      operation: event.operation,\n      input: event.input,\n      output: event.output,\n      inverse: mapping.inverse,\n      inverseInput,\n      timestamp: event.timestamp,\n    };\n\n    history.push(entry);\n    log('history entry added', { key: event.operation.meta.key, historyLength: history.length });\n\n    // Trim history if it exceeds limit.\n    if (history.length > HISTORY_LIMIT) {\n      history.splice(0, history.length - HISTORY_LIMIT);\n    }\n\n    // Show undo toast (resolve message if it's a function).\n    const resolvedMessage = resolveMessage(mapping.message, event.input, event.output);\n    Effect.runFork(\n      invoker.invoke(UndoOperation.ShowUndo, {\n        message: resolvedMessage,\n      }),\n    );\n  };\n\n  // Fork a fiber to consume the invocation stream.\n  Effect.runFork(\n    Stream.fromPubSub(invoker.invocations).pipe(\n      Stream.runForEach((event) => Effect.sync(() => handleInvocation(event))),\n    ),\n  );\n\n  const undo = (): Effect.Effect<void, Error> => {\n    return Effect.gen(function* () {\n      const entry = history.pop();\n      if (!entry) {\n        return yield* Effect.fail(new EmptyHistoryError());\n      }\n\n      log('undoing operation', { key: entry.operation.meta.key, inverseKey: entry.inverse.meta.key });\n\n      // Use _invokeCore to skip event emission (avoid undo-of-undo loops).\n      yield* invoker._invokeCore(entry.inverse, entry.inverseInput);\n\n      log('undo completed', { key: entry.operation.meta.key });\n    });\n  };\n\n  const undoPromise = async (): Promise<{ error?: Error }> => {\n    return runAndForwardErrors(undo())\n      .then(() => ({}))\n      .catch((error) => {\n        log.catch(error);\n        return { error };\n      });\n  };\n\n  const canUndo = (): boolean => {\n    return history.length > 0;\n  };\n\n  return {\n    undo,\n    undoPromise,\n    canUndo,\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["BaseError", "EmptyHistoryError", "BaseError", "extend", "make", "props", "resolveMessage", "message", "input", "output", "undefined", "make", "make", "getMappings", "lookup", "operation", "mappings", "mapping", "find", "m", "meta", "key", "undefined", "inverse", "deriveContext", "message", "make", "Effect", "Stream", "runAndForwardErrors", "log", "HISTORY_LIMIT", "make", "invoker", "undoRegistry", "history", "handleInvocation", "event", "mapping", "lookup", "operation", "inverseInput", "deriveContext", "input", "output", "undefined", "log", "key", "meta", "entry", "inverse", "timestamp", "push", "historyLength", "length", "splice", "resolvedMessage", "resolveMessage", "message", "Effect", "runFork", "invoke", "UndoOperation", "ShowUndo", "fromPubSub", "invocations", "pipe", "runForEach", "sync", "undo", "gen", "pop", "fail", "EmptyHistoryError", "inverseKey", "_invokeCore", "undoPromise", "runAndForwardErrors", "then", "catch", "error", "canUndo"]
+}

package/dist/lib/node-esm/chunk-VKHGNEDB.mjs

@@ -0,0 +1,43 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  capability_exports
+} from "./chunk-42KBWDE4.mjs";
+
+// src/common/translations.ts
+import * as Schema from "effect/Schema";
+var Label = Schema.Union(Schema.String, Schema.mutable(Schema.Tuple(Schema.String, Schema.mutable(Schema.Struct({
+  ns: Schema.String,
+  count: Schema.optional(Schema.Number),
+  defaultValue: Schema.optional(Schema.String)
+})))));
+
+// src/common/operations.ts
+import * as Schema2 from "effect/Schema";
+import { Operation } from "@dxos/operation";
+var UNDO_NAMESPACE = "org.dxos.app-framework.undo";
+(function(UndoOperation2) {
+  UndoOperation2.ShowUndo = Operation.make({
+    meta: {
+      key: `${UNDO_NAMESPACE}.operation.show-undo`,
+      name: "Show Undo",
+      description: "Show an undo toast notification."
+    },
+    executionMode: "sync",
+    services: [
+      capability_exports.Service
+    ],
+    input: Schema2.Struct({
+      message: Schema2.optional(Label.annotations({
+        description: "The message to display in the undo toast."
+      }))
+    }),
+    output: Schema2.Void
+  });
+})(UndoOperation || (UndoOperation = {}));
+var UndoOperation;
+
+export {
+  Label,
+  UndoOperation
+};
+//# sourceMappingURL=chunk-VKHGNEDB.mjs.map

package/dist/lib/node-esm/chunk-VKHGNEDB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/common/translations.ts", "../../../src/common/operations.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * A Label represents translatable text - either a simple string or a tuple of [key, options].\n */\nexport const Label = Schema.Union(\n  Schema.String,\n  Schema.mutable(\n    Schema.Tuple(\n      Schema.String,\n      Schema.mutable(\n        Schema.Struct({\n          ns: Schema.String,\n          count: Schema.optional(Schema.Number),\n          defaultValue: Schema.optional(Schema.String),\n        }),\n      ),\n    ),\n  ),\n);\nexport type Label = Schema.Schema.Type<typeof Label>;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Operation } from '@dxos/operation';\n\nimport { Capability } from '../core';\nimport { Label } from './translations';\n\nconst UNDO_NAMESPACE = 'org.dxos.app-framework.undo';\n\n/**\n * Operations related to undo/history functionality.\n */\nexport namespace UndoOperation {\n  /**\n   * Show an undo toast notification.\n   * Fired by HistoryTracker when an undoable operation is tracked.\n   */\n  export const ShowUndo = Operation.make({\n    meta: {\n      key: `${UNDO_NAMESPACE}.operation.show-undo`,\n      name: 'Show Undo',\n      description: 'Show an undo toast notification.',\n    },\n    executionMode: 'sync',\n    services: [Capability.Service],\n    input: Schema.Struct({\n      message: Schema.optional(Label.annotations({ description: 'The message to display in the undo toast.' })),\n    }),\n    output: Schema.Void,\n  });\n}\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAKjB,IAAMC,QAAeC,aACnBC,eACAC,eACEC,aACEF,eACAC,eACEE,cAAO;EACZC,IAAWJ;EACXK,OAAcC,gBAAgBC,aAAM;EACpCC,cAAqBF,gBAAgBN,aAAM;AAC7C,CAAA,CAAA,CAAA,CAAA,CAAA;;;ACfR,YAAYS,aAAY;AAExB,SAASC,iBAAiB;AAK1B,IAAMC,iBAAiB;UAKNC,gBAAAA;iBAKFC,WAAWC,UAAUC,KAAK;IACrCC,MAAM;MACJC,KAAK,GAAGN,cAAAA;MACRO,MAAM;MACNC,aAAa;IACf;IACAC,eAAe;IACfC,UAAU;MAACC,mBAAWC;;IACtBC,OAAcC,eAAO;MACnBC,SAAgBC,iBAASC,MAAMC,YAAY;QAAEV,aAAa;MAA4C,CAAA,CAAA;IACxG,CAAA;IACAW,QAAeC;EACjB,CAAA;AACF,GAlBiBnB,kBAAAA,gBAAAA,CAAAA,EAAAA;;",
+  "names": ["Schema", "Label", "Union", "String", "mutable", "Tuple", "Struct", "ns", "count", "optional", "Number", "defaultValue", "Schema", "Operation", "UNDO_NAMESPACE", "UndoOperation", "ShowUndo", "Operation", "make", "meta", "key", "name", "description", "executionMode", "services", "Capability", "Service", "input", "Struct", "message", "optional", "Label", "annotations", "output", "Void"]
+}