@opengeni/artifact-tool 0.2.2

package/dist/chunk-HTJBLBDE.js

@@ -0,0 +1,591 @@
+// src/production-composite.ts
+var ROOT_KEY = "$root";
+var PROXY_METADATA = /* @__PURE__ */ new WeakMap();
+var QUERY_METHODS = /* @__PURE__ */ new Set([
+  "allStoryBlocks",
+  "arrayBuffer",
+  "at",
+  "entries",
+  "every",
+  "export",
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "forBlock",
+  "forEach",
+  "getActiveWorksheet",
+  "getCell",
+  "getItem",
+  "getItemAt",
+  "getRange",
+  "getRangeByIndexes",
+  "getUsedRange",
+  "help",
+  "includes",
+  "indexOf",
+  "inspect",
+  "inspectRecord",
+  "join",
+  "keys",
+  "lastIndexOf",
+  "layoutSnapshot",
+  "map",
+  "ownsObject",
+  "reduce",
+  "reduceRight",
+  "render",
+  "resolve",
+  "resize",
+  "serialize",
+  "slice",
+  "some",
+  "summary",
+  "text",
+  "toJSON",
+  "toLocaleString",
+  "toProto",
+  "toString",
+  "trace",
+  "values"
+]);
+var ARRAY_CALLBACK_METHODS = /* @__PURE__ */ new Set([
+  "every",
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "flatMap",
+  "forEach",
+  "map",
+  "reduce",
+  "reduceRight",
+  "some"
+]);
+var ARRAY_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "copyWithin",
+  "fill",
+  "pop",
+  "push",
+  "reverse",
+  "shift",
+  "sort",
+  "splice",
+  "unshift"
+]);
+var CompositeArtifactState = class {
+  modality;
+  namespace;
+  #root;
+  #native;
+  #nativeData;
+  #revision;
+  #disposedError;
+  #disposed = false;
+  #mutationDepth = 0;
+  #asyncMutation = false;
+  #reconcileProjection;
+  #prepareMutation;
+  #proxies = /* @__PURE__ */ new Map();
+  #functions = /* @__PURE__ */ new Map();
+  #changeListeners = /* @__PURE__ */ new Set();
+  #installProjection;
+  #readProperty;
+  #captureAuxiliary;
+  #restoreAuxiliary;
+  constructor(input) {
+    this.modality = input.modality;
+    this.namespace = input.namespace;
+    this.#root = input.root;
+    this.#native = input.reconciliation.session;
+    this.#nativeData = input.reconciliation.data;
+    this.#revision = safeRevision(this.#native.revision());
+    this.#reconcileProjection = input.reconcile;
+    this.#prepareMutation = input.prepareMutation;
+    this.#installProjection = input.installProjection;
+    this.#readProperty = input.readProperty;
+    this.#captureAuxiliary = input.captureAuxiliary;
+    this.#restoreAuxiliary = input.restoreAuxiliary;
+    this.#disposedError = new Error(`${input.modality} artifact is disposed`);
+    this.#installProjection?.(this.#root, this);
+  }
+  get root() {
+    this.assertUsable();
+    return this.#root;
+  }
+  get native() {
+    this.assertUsable();
+    return this.#native;
+  }
+  get nativeData() {
+    this.assertUsable();
+    return this.#nativeData;
+  }
+  /** Monotonic facade revision across retained and rare replacement sessions. */
+  get revision() {
+    this.assertUsable();
+    return this.#revision;
+  }
+  /** True only inside one explicit/public mutation transaction. */
+  get inMutation() {
+    return this.#mutationDepth > 0;
+  }
+  proxy() {
+    return this.wrap(rootLocator());
+  }
+  rawRoot() {
+    this.assertUsable();
+    return this.#root;
+  }
+  assertUsable() {
+    if (this.#disposed) throw this.#disposedError;
+    if (this.#asyncMutation && this.#mutationDepth === 0) {
+      throw new Error(`${this.modality} artifact mutation is still in progress`);
+    }
+  }
+  onWorkbookChange(listener) {
+    this.assertUsable();
+    if (this.modality !== "spreadsheet") {
+      throw new Error("Workbook change listeners are only available for spreadsheets");
+    }
+    this.#changeListeners.add(listener);
+    return () => this.#changeListeners.delete(listener);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#native.dispose();
+    this.#changeListeners.clear();
+    this.#proxies.clear();
+    this.#functions.clear();
+    this.#disposed = true;
+  }
+  mutate(operation, hint) {
+    this.assertUsable();
+    if (this.#mutationDepth > 0) return operation();
+    const prepared = this.#prepareMutation?.(hint, this) ?? null;
+    const acceptedRoot = prepared ? null : cloneProjectionGraph(this.#root);
+    const acceptedAuxiliary = prepared ? void 0 : this.#captureAuxiliary?.(this.#root);
+    this.#mutationDepth = 1;
+    let result;
+    try {
+      result = operation();
+    } catch (cause) {
+      if (acceptedRoot) this.#restoreProjection(acceptedRoot, acceptedAuxiliary);
+      this.#mutationDepth = 0;
+      throw cause;
+    }
+    if (isPromiseLike(result)) {
+      this.#asyncMutation = true;
+      return result.then(
+        (value) => {
+          try {
+            this.#acceptProjection(hint, prepared, value);
+            return value;
+          } catch (cause) {
+            if (acceptedRoot) this.#restoreProjection(acceptedRoot, acceptedAuxiliary);
+            else this.#poisonAfterIncrementalFailure();
+            throw cause;
+          } finally {
+            this.#mutationDepth = 0;
+            this.#asyncMutation = false;
+          }
+        },
+        (cause) => {
+          if (acceptedRoot) this.#restoreProjection(acceptedRoot, acceptedAuxiliary);
+          this.#mutationDepth = 0;
+          this.#asyncMutation = false;
+          throw cause;
+        }
+      );
+    }
+    try {
+      this.#acceptProjection(hint, prepared, result);
+      return result;
+    } catch (cause) {
+      if (acceptedRoot) this.#restoreProjection(acceptedRoot, acceptedAuxiliary);
+      else this.#poisonAfterIncrementalFailure();
+      throw cause;
+    } finally {
+      this.#mutationDepth = 0;
+    }
+  }
+  wrap(locator) {
+    this.assertUsable();
+    const existing = this.#proxies.get(locator.key);
+    if (existing) return existing;
+    const current = locator.resolve(this.#root);
+    if (!isProxyCandidate(current)) return current;
+    const target = Array.isArray(current) ? [] : {};
+    const proxy = new Proxy(target, this.#handler(locator));
+    this.#proxies.set(locator.key, proxy);
+    PROXY_METADATA.set(proxy, {
+      state: this,
+      locator
+    });
+    return proxy;
+  }
+  #handler(locator) {
+    return {
+      get: (_target, member) => {
+        this.assertUsable();
+        const owner = locator.resolve(this.#root);
+        if (!isObject(owner)) return void 0;
+        if (locator.key === ROOT_KEY) {
+          if (member === "batch") {
+            return this.#rootFunction("batch", (callback) => {
+              if (typeof callback !== "function") {
+                throw new TypeError("Artifact batch callback must be a function");
+              }
+              return this.mutate(() => callback(this.proxy()), {
+                member: "batch",
+                owner: this.#root,
+                arguments: [callback]
+              });
+            });
+          }
+          if (member === "dispose") return this.#rootFunction("dispose", () => this.dispose());
+          if (member === "onChange" && this.modality === "spreadsheet") {
+            return this.#rootFunction("onChange", (listener) => {
+              if (typeof listener !== "function")
+                throw new TypeError("Workbook listener must be a function");
+              return this.onWorkbookChange(listener);
+            });
+          }
+          if (member === "recalculate" && this.modality === "spreadsheet") {
+            return this.#rootFunction("recalculate", () => void 0);
+          }
+          if (member === "revision" && (this.modality === "spreadsheet" || this.modality === "document")) {
+            return this.#revision;
+          }
+        }
+        if (Array.isArray(owner) && member === Symbol.iterator) {
+          return this.#arrayIterator(locator, owner);
+        }
+        const projected = this.#readProperty?.(owner, member, this);
+        const value = projected?.handled === true ? projected.value : Reflect.get(owner, member, owner);
+        if (typeof value === "function") {
+          const functionKey = `${locator.key}.${propertyKey(member)}`;
+          const cached = this.#functions.get(functionKey);
+          if (cached) return cached;
+          const wrapped = (...args) => {
+            this.assertUsable();
+            const currentOwner = locator.resolve(this.#root);
+            if (!isObject(currentOwner)) throw new Error("Artifact object no longer exists");
+            const currentMethod = Reflect.get(currentOwner, member, currentOwner);
+            if (typeof currentMethod !== "function")
+              throw new TypeError(`${String(member)} is not callable`);
+            const invocationArgs = Array.isArray(currentOwner) && ARRAY_CALLBACK_METHODS.has(member) ? this.#arrayCallbackArguments(locator, args) : args.map(unwrapArtifactValue);
+            const invoke = () => currentMethod.apply(currentOwner, invocationArgs);
+            const mutates = Array.isArray(currentOwner) ? ARRAY_MUTATION_METHODS.has(member) : !QUERY_METHODS.has(member);
+            const result = mutates ? this.mutate(invoke, { member, owner: currentOwner, arguments: invocationArgs }) : invoke();
+            return this.#wrapReturn(locator, member, result);
+          };
+          this.#functions.set(functionKey, wrapped);
+          return wrapped;
+        }
+        return this.#wrapProperty(locator, member, value);
+      },
+      set: (_target, member, value) => {
+        this.assertUsable();
+        const owner = locator.resolve(this.#root);
+        if (!isObject(owner)) throw new Error("Artifact object no longer exists");
+        return this.mutate(() => Reflect.set(owner, member, unwrapArtifactValue(value), owner), {
+          member,
+          owner,
+          arguments: [unwrapArtifactValue(value)]
+        });
+      },
+      deleteProperty: (_target, member) => {
+        this.assertUsable();
+        const owner = locator.resolve(this.#root);
+        if (!isObject(owner)) throw new Error("Artifact object no longer exists");
+        return this.mutate(() => Reflect.deleteProperty(owner, member), {
+          member,
+          owner,
+          arguments: []
+        });
+      },
+      has: (_target, member) => {
+        const owner = locator.resolve(this.#root);
+        return isObject(owner) && member in owner;
+      },
+      getPrototypeOf: () => {
+        const owner = locator.resolve(this.#root);
+        return isObject(owner) ? Object.getPrototypeOf(owner) : null;
+      },
+      ownKeys: (target) => {
+        const owner = locator.resolve(this.#root);
+        const keys = isObject(owner) ? Reflect.ownKeys(owner) : [];
+        if (Array.isArray(target) && !keys.includes("length")) keys.push("length");
+        return keys;
+      },
+      getOwnPropertyDescriptor: (target, member) => {
+        if (Array.isArray(target) && member === "length") {
+          return Reflect.getOwnPropertyDescriptor(target, "length");
+        }
+        const owner = locator.resolve(this.#root);
+        const descriptor = isObject(owner) ? Reflect.getOwnPropertyDescriptor(owner, member) : void 0;
+        return descriptor ? { ...descriptor, configurable: true } : void 0;
+      }
+    };
+  }
+  #acceptProjection(hint, prepared, result) {
+    if (prepared) {
+      const changed = prepared.commit(result);
+      if (changed) {
+        this.#revision = Math.max(this.#revision + 1, safeRevision(this.#native.revision()));
+        this.#emitWorkbookChange(hint);
+      }
+      return;
+    }
+    const accepted = this.#reconcileProjection(this.#root);
+    const previous = this.#native;
+    this.#native = accepted.session;
+    this.#nativeData = accepted.data;
+    this.#revision = Math.max(this.#revision + 1, safeRevision(this.#native.revision()));
+    try {
+      previous.dispose();
+    } catch {
+    }
+    this.#emitWorkbookChange(hint);
+  }
+  #poisonAfterIncrementalFailure() {
+    try {
+      this.#native.dispose();
+    } finally {
+      this.#disposed = true;
+      this.#changeListeners.clear();
+    }
+  }
+  #restoreProjection(root, auxiliary) {
+    this.#root = root;
+    this.#installProjection?.(this.#root, this);
+    this.#restoreAuxiliary?.(this.#root, auxiliary);
+  }
+  #emitWorkbookChange(hint) {
+    if (this.modality !== "spreadsheet" || this.#changeListeners.size === 0) return;
+    const root = this.#root;
+    const owner = hint.owner;
+    const ownerSheet = typeof owner?.id === "string" && owner.id.startsWith("ws/") ? owner.id : typeof owner?.worksheet?.id === "string" ? owner.worksheet.id : null;
+    const sheetIds = ownerSheet ? [ownerSheet] : (root.worksheets?.items ?? []).map((sheet) => sheet.id).filter((id) => typeof id === "string");
+    const member = String(hint.member).toLowerCase();
+    const reason = member.includes("format") || member.includes("style") ? "format" : member.includes("comment") || member.includes("reply") ? "comment" : member.includes("width") || member.includes("height") ? "dimension" : member.includes("chart") || member.includes("image") || member.includes("shape") || member.includes("sparkline") ? "drawing" : member.includes("sheet") || member === "add" || member === "name" ? "structure" : "content";
+    const change = Object.freeze({
+      revision: this.#revision,
+      sheetIds: Object.freeze([...new Set(sheetIds)].sort()),
+      reason
+    });
+    for (const listener of this.#changeListeners) listener(change);
+  }
+  #rootFunction(name, implementation) {
+    const key = `${ROOT_KEY}.${name}`;
+    const existing = this.#functions.get(key);
+    if (existing) return existing;
+    this.#functions.set(key, implementation);
+    return implementation;
+  }
+  #wrapProperty(parent, member, value) {
+    if (!isProxyCandidate(value)) return value;
+    const stable = this.#stableLocator(value);
+    return this.wrap(stable ?? propertyLocator(parent, member));
+  }
+  #wrapReturn(parent, member, value) {
+    if (isPromiseLike(value)) {
+      return value.then((resolved) => this.#wrapReturn(parent, member, resolved));
+    }
+    if (!isProxyCandidate(value)) return value;
+    const stable = this.#stableLocator(value);
+    if (stable) return this.wrap(stable);
+    if (isRangeLike(value)) return this.wrap(rangeLocator(value));
+    return value;
+  }
+  #stableLocator(value) {
+    const id = Reflect.get(value, "id");
+    if (typeof id !== "string") return null;
+    const root = this.#root;
+    if (typeof root.resolve !== "function") return null;
+    try {
+      if (root.resolve(id) !== value) return null;
+    } catch {
+      return null;
+    }
+    return {
+      key: `id:${id}`,
+      resolve: (candidateRoot) => {
+        const resolve = candidateRoot.resolve;
+        if (typeof resolve !== "function") throw new Error(`Artifact cannot resolve ${id}`);
+        return resolve.call(candidateRoot, id);
+      }
+    };
+  }
+  #arrayIterator(locator, owner) {
+    const current = () => locator.resolve(this.#root);
+    const wrap = (index, value) => this.#wrapProperty(locator, String(index), value);
+    return function* iterator() {
+      for (let index = 0; index < owner.length; index += 1) {
+        const currentArray = current();
+        if (!Array.isArray(currentArray) || index >= currentArray.length) return;
+        yield wrap(index, currentArray[index]);
+      }
+    };
+  }
+  #arrayCallbackArguments(locator, args) {
+    if (typeof args[0] !== "function") return args.map(unwrapArtifactValue);
+    const callback = args[0];
+    const thisArg = args[1];
+    const wrapChild = (index, value) => this.#wrapProperty(locator, String(index), value);
+    const wrappedArray = () => this.wrap(locator);
+    const wrappedCallback = function(value, index) {
+      const child = typeof index === "number" ? wrapChild(index, value) : value;
+      return callback.call(thisArg ?? this, child, index, wrappedArray());
+    };
+    return [wrappedCallback, thisArg];
+  }
+};
+function stateOf(value) {
+  if (!isObject(value)) return null;
+  return PROXY_METADATA.get(value)?.state ?? null;
+}
+function requireCompositeState(value, modality) {
+  const state = stateOf(value);
+  if (!state) throw new TypeError("Expected an artifact created by the production facade");
+  state.assertUsable();
+  if (modality && state.modality !== modality) {
+    throw new TypeError(`Expected a ${modality} artifact`);
+  }
+  return state;
+}
+function unwrapArtifactValue(value) {
+  if (!isObject(value)) return value;
+  const metadata = PROXY_METADATA.get(value);
+  if (metadata) return metadata.locator.resolve(metadata.state.rawRoot());
+  if (Array.isArray(value)) return value.map(unwrapArtifactValue);
+  if (!isPlainObject(value)) return value;
+  const output = {};
+  for (const key of Reflect.ownKeys(value))
+    output[key] = unwrapArtifactValue(Reflect.get(value, key));
+  return output;
+}
+function rootLocator() {
+  return { key: ROOT_KEY, resolve: (root) => root };
+}
+function propertyLocator(parent, member) {
+  return {
+    key: `${parent.key}.${propertyKey(member)}`,
+    resolve(root) {
+      const owner = parent.resolve(root);
+      if (!isObject(owner)) throw new Error("Artifact parent object no longer exists");
+      return Reflect.get(owner, member, owner);
+    }
+  };
+}
+function rangeLocator(range) {
+  const worksheet = Reflect.get(range, "worksheet");
+  const address = Reflect.get(range, "address");
+  if (typeof worksheet?.id !== "string" || !Number.isInteger(address?.row) || !Number.isInteger(address?.col) || !Number.isInteger(address?.rowCount) || !Number.isInteger(address?.colCount)) {
+    throw new Error("Cannot locate spreadsheet range");
+  }
+  const row = address.row;
+  const col = address.col;
+  const rowCount = address.rowCount;
+  const colCount = address.colCount;
+  const sheetId = worksheet.id;
+  return {
+    key: `range:${sheetId}:${row}:${col}:${rowCount}:${colCount}`,
+    resolve(root) {
+      const workbook = root;
+      const sheet = workbook.resolve?.(sheetId);
+      if (!sheet || typeof sheet.getRangeByIndexes !== "function") {
+        throw new Error(`Worksheet no longer exists: ${sheetId}`);
+      }
+      return sheet.getRangeByIndexes(row, col, rowCount, colCount);
+    }
+  };
+}
+function isRangeLike(value) {
+  const address = Reflect.get(value, "address");
+  const worksheet = Reflect.get(value, "worksheet");
+  return isObject(address) && isObject(worksheet) && typeof Reflect.get(worksheet, "id") === "string";
+}
+function isProxyCandidate(value) {
+  if (!isObject(value)) return false;
+  if (value instanceof Date || value instanceof RegExp || value instanceof ArrayBuffer || ArrayBuffer.isView(value) || value instanceof Blob || value instanceof Map || value instanceof Set || value instanceof Promise || Object.isFrozen(value)) {
+    return false;
+  }
+  return true;
+}
+function cloneProjectionGraph(root) {
+  return cloneGraph(root, /* @__PURE__ */ new Map());
+}
+function cloneGraph(value, seen) {
+  if (!isObject(value) || typeof value === "function") return value;
+  const known = seen.get(value);
+  if (known !== void 0) return known;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
+  if (value instanceof ArrayBuffer) return value.slice(0);
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView) {
+      return new DataView(
+        value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength)
+      );
+    }
+    const constructor = value.constructor;
+    return new constructor(value);
+  }
+  if (value instanceof Blob) return value.slice(0, value.size, value.type);
+  if (value instanceof Map) {
+    const output2 = /* @__PURE__ */ new Map();
+    seen.set(value, output2);
+    for (const [key, entry] of value) output2.set(cloneGraph(key, seen), cloneGraph(entry, seen));
+    return output2;
+  }
+  if (value instanceof Set) {
+    const output2 = /* @__PURE__ */ new Set();
+    seen.set(value, output2);
+    for (const entry of value) output2.add(cloneGraph(entry, seen));
+    return output2;
+  }
+  if (value instanceof WeakMap || value instanceof WeakSet || value instanceof Promise)
+    return value;
+  const output = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+  seen.set(value, output);
+  for (const key of Reflect.ownKeys(value)) {
+    if (Array.isArray(value) && key === "length") continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) continue;
+    if ("value" in descriptor) descriptor.value = cloneGraph(descriptor.value, seen);
+    Reflect.defineProperty(output, key, descriptor);
+  }
+  if (Object.isFrozen(value)) Object.freeze(output);
+  else if (Object.isSealed(value)) Object.seal(output);
+  else if (!Object.isExtensible(value)) Object.preventExtensions(output);
+  return output;
+}
+function safeRevision(value) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError("Native artifact revision exceeds the JavaScript safe-integer range");
+  }
+  return Number(value);
+}
+function propertyKey(value) {
+  return typeof value === "symbol" ? `symbol:${value.description ?? ""}` : String(value);
+}
+function isPromiseLike(value) {
+  return isObject(value) && typeof Reflect.get(value, "then") === "function";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+export {
+  CompositeArtifactState,
+  requireCompositeState
+};
+//# sourceMappingURL=chunk-HTJBLBDE.js.map