@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-IKHBXETN.js

@@ -0,0 +1,174 @@
+import {
+  resolveDocumentModelContext
+} from "./chunk-KB3CY3QO.js";
+import {
+  CommentsPart,
+  CoreProperties,
+  CorePropertiesPartView,
+  DocumentPartView,
+  FooterPart,
+  HeaderPart,
+  ImagePartView,
+  ImageParts,
+  NumberingPart,
+  PackageView,
+  PartView,
+  RelationshipView,
+  Relationships,
+  SettingsPart,
+  StoryPart,
+  StylesPart,
+  XmlPartView,
+  _NumberingDefinitions
+} from "./chunk-RZJRR4UJ.js";
+import {
+  acquireDocumentTransportInput
+} from "./chunk-ZXKOMB24.js";
+import {
+  acquireImageModelInput
+} from "./chunk-A7EMM3SB.js";
+import {
+  docxOperationSchemas
+} from "./chunk-R4TYL2G6.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/package-view-batch-operations.ts
+var packageActions = /* @__PURE__ */ new Map();
+function action(id, owner, apply) {
+  packageActions.set(id, (receiver, args) => {
+    if (!(receiver instanceof owner)) throw new DocxUsageError("The receiver does not support this package view operation.");
+    return apply(receiver, args);
+  });
+}
+for (const prefix2 of ["model.package.Package", "model.opc.package.OpcPackage"]) {
+  packageActions.set(`${prefix2}.open.call`, async (_receiver, args, context) => {
+    const transport = args.context;
+    if (transport?.template !== void 0) throw new DocxUsageError("A context template conflicts with package input.");
+    const selected = await resolveDocumentModelContext(transport, context);
+    if (selected.template !== void 0) throw new DocxUsageError("A context template conflicts with package input.");
+    const bytes = await acquireDocumentTransportInput(args.pkgFile, selected);
+    return PackageView.open(bytes, selected);
+  });
+  for (const name of ["parts", "rels", "main_document_part", "core_properties", "image_parts"]) action(`${prefix2}.${name}.get`, PackageView, (receiver) => receiver[name]);
+  action(`${prefix2}.iter_parts.call`, PackageView, (receiver) => [...receiver.iter_parts()]);
+  action(`${prefix2}.iter_rels.call`, PackageView, (receiver) => [...receiver.iter_rels()]);
+  action(`${prefix2}.after_unmarshal.call`, PackageView, (receiver) => receiver.after_unmarshal());
+  action(`${prefix2}.part_related_by.call`, PackageView, (receiver, args) => receiver.part_related_by(args.reltype));
+  action(`${prefix2}.relate_to.call`, PackageView, (receiver, args) => receiver.relate_to(args.part, args.reltype));
+  action(`${prefix2}.load_rel.call`, PackageView, (receiver, args) => receiver.load_rel(args.reltype, args.target, args.rId, args.isExternal));
+  action(`${prefix2}.next_partname.call`, PackageView, (receiver, args) => receiver.next_partname(args.template));
+}
+var partOwners = [["model.opc.part.Part", PartView], ["model.opc.part.XmlPart", XmlPartView], ["model.parts.document.DocumentPart", DocumentPartView], ["model.parts.story.StoryPart", StoryPart], ["model.parts.hdrftr.HeaderPart", HeaderPart], ["model.parts.hdrftr.FooterPart", FooterPart], ["model.parts.comments.CommentsPart", CommentsPart], ["model.parts.settings.SettingsPart", SettingsPart], ["model.parts.numbering.NumberingPart", NumberingPart], ["model.parts.styles.StylesPart", StylesPart], ["model.parts.image.ImagePart", ImagePartView], ["model.opc.parts.coreprops.CorePropertiesPart", CorePropertiesPartView]];
+for (const [prefix2, owner] of partOwners) {
+  for (const name of ["blob", "content_type", "partname", "package", "rels", "related_parts"]) action(`${prefix2}.${name}.get`, owner, (receiver) => receiver[name]);
+  action(`${prefix2}.partname.set`, owner, (receiver, args) => {
+    receiver.partname = args.value;
+  });
+  action(`${prefix2}.part_related_by.call`, owner, (receiver, args) => receiver.part_related_by(args.reltype));
+  action(`${prefix2}.target_ref.call`, owner, (receiver, args) => receiver.target_ref(args.rId));
+  action(`${prefix2}.relate_to.call`, owner, (receiver, args) => receiver.relate_to(args.target, args.reltype, args.isExternal));
+  action(`${prefix2}.load_rel.call`, owner, (receiver, args) => receiver.load_rel(args.reltype, args.target, args.rId, args.isExternal));
+  action(`${prefix2}.drop_rel.call`, owner, (receiver, args) => receiver.drop_rel(args.rId));
+  action(`${prefix2}.before_marshal.call`, owner, (receiver) => receiver.before_marshal());
+  action(`${prefix2}.after_unmarshal.call`, owner, (receiver) => receiver.after_unmarshal());
+}
+for (const [prefix2, owner] of partOwners) {
+  if (owner !== XmlPartView && !(owner.prototype instanceof XmlPartView)) continue;
+  const xmlOwner = owner;
+  action(`${prefix2}.element.get`, xmlOwner, (receiver) => receiver.element);
+  action(`${prefix2}.part.get`, xmlOwner, (receiver) => receiver.part);
+}
+var prefix = "model.opc.rel.Relationships";
+for (const name of ["related_parts", "xml"]) action(`${prefix}.${name}.get`, Relationships, (receiver) => receiver[name]);
+action(`${prefix}.add_relationship.call`, Relationships, (receiver, args) => receiver.add_relationship(args.reltype, args.target, args.rId, args.isExternal));
+action(`${prefix}.get_or_add.call`, Relationships, (receiver, args) => receiver.get_or_add(args.reltype, args.targetPart));
+action(`${prefix}.get_or_add_ext_rel.call`, Relationships, (receiver, args) => receiver.get_or_add_ext_rel(args.reltype, args.targetRef));
+action(`${prefix}.part_with_reltype.call`, Relationships, (receiver, args) => receiver.part_with_reltype(args.reltype));
+action(`${prefix}.__getitem__.call`, Relationships, (receiver, args) => receiver.at(args.rId));
+action(`${prefix}.__setitem__.call`, Relationships, (receiver, args) => receiver.set(args.rId, args.value));
+action(`${prefix}.__delitem__.call`, Relationships, (receiver, args) => receiver.delete(args.rId));
+action(`${prefix}.__len__.get`, Relationships, (receiver) => receiver.length);
+action(`${prefix}.__iter__.call`, Relationships, (receiver) => [...receiver]);
+action(`${prefix}.__contains__.call`, Relationships, (receiver, args) => receiver.has(args.rId));
+for (const name of ["keys", "values", "items"]) action(`${prefix}.${name}.call`, Relationships, (receiver) => [...receiver[name]()]);
+action(`${prefix}.get.call`, Relationships, (receiver, args) => receiver.get(args.rId, args.defaultValue));
+action(`${prefix}.clear.call`, Relationships, (receiver) => receiver.clear());
+action(`${prefix}.update.call`, Relationships, (receiver, args) => receiver.update(args.entries));
+action(`${prefix}.pop.call`, Relationships, (receiver, args) => Object.hasOwn(args, "defaultValue") ? receiver.pop(args.rId, args.defaultValue) : receiver.pop(args.rId));
+action(`${prefix}.popitem.call`, Relationships, (receiver) => receiver.popitem());
+action(`${prefix}.setdefault.call`, Relationships, (receiver, args) => receiver.setdefault(args.rId, args.value));
+action(`${prefix}.copy.call`, Relationships, (receiver) => receiver.copy());
+for (const name of ["rId", "reltype", "is_external", "target_ref", "target_part"])
+  action(`model.opc.rel._Relationship.${name}.get`, RelationshipView, (receiver) => receiver[name]);
+for (const name of ["title", "subject", "author", "keywords", "comments", "last_modified_by", "category", "content_status", "identifier", "language", "version", "revision", "created", "modified", "last_printed"]) {
+  action(`model.opc.coreprops.CoreProperties.${name}.get`, CoreProperties, (receiver) => receiver[name]);
+  action(`model.opc.coreprops.CoreProperties.${name}.set`, CoreProperties, (receiver, args) => {
+    const value = ["created", "modified", "last_printed"].includes(name) && typeof args.value === "string" ? new Date(args.value) : args.value;
+    Reflect.set(receiver, name, value);
+  });
+}
+action("model.opc.parts.coreprops.CorePropertiesPart.core_properties.get", CorePropertiesPartView, (receiver) => receiver.core_properties);
+action("model.opc.coreprops.CoreProperties.part.get", CoreProperties, (receiver) => receiver.part);
+action("model.opc.coreprops.CoreProperties.element.get", CoreProperties, (receiver) => receiver.element);
+for (const [prefix2, owner] of partOwners) {
+  packageActions.set(`${prefix2}.load.call`, async (_receiver, args, context) => {
+    const acquired = await acquireImageModelInput(args.blob, context);
+    return owner.load(args.partname, args.contentType, acquired.bytes, args.ownerPackage);
+  });
+}
+for (const [prefix2, owner] of [["model.parts.hdrftr.HeaderPart", HeaderPart], ["model.parts.hdrftr.FooterPart", FooterPart]])
+  packageActions.set(`${prefix2}.new.call`, (_receiver, args) => owner.new(args.ownerPackage));
+for (const [prefix2, owner] of [["model.parts.comments.CommentsPart", CommentsPart], ["model.parts.settings.SettingsPart", SettingsPart], ["model.parts.styles.StylesPart", StylesPart]])
+  packageActions.set(`${prefix2}.default.call`, (_receiver, args) => owner.default(args.ownerPackage));
+packageActions.set("model.opc.parts.coreprops.CorePropertiesPart.default.call", (_receiver, args) => CorePropertiesPartView.default(args.ownerPackage));
+for (const name of ["default_cx", "default_cy", "filename", "image", "sha1"]) action(`model.parts.image.ImagePart.${name}.get`, ImagePartView, (receiver) => receiver[name]);
+action("model.package.ImageParts.__contains__.call", ImageParts, (receiver, args) => receiver.has(args.value));
+action("model.package.ImageParts.__iter__.call", ImageParts, (receiver) => [...receiver]);
+action("model.package.ImageParts.__len__.get", ImageParts, (receiver) => receiver.length);
+action("model.package.ImageParts.append.call", ImageParts, (receiver, args) => receiver.append(args.item));
+for (const [id, owner] of [["model.package.Package.get_or_add_image_part.call", PackageView], ["model.package.ImageParts.get_or_add_image_part.call", ImageParts]]) {
+  packageActions.set(id, async (receiver, args, context) => {
+    if (!(receiver instanceof owner)) throw new DocxUsageError("Expected an admitted image owner.");
+    const descriptor = args.imageDescriptor;
+    if (!(descriptor instanceof Uint8Array) && "path" in descriptor) return receiver.get_or_add_image_part({ path: descriptor.path, capability: descriptor.capability });
+    const acquired = await acquireImageModelInput(descriptor, context);
+    return receiver.get_or_add_image_part(acquired.bytes);
+  });
+}
+packageActions.set("model.parts.image.ImagePart.from_image.call", (_receiver, args) => ImagePartView.from_image(args.image, args.partname, args.ownerPackage));
+for (const [prefix2, owner] of [["model.parts.document.DocumentPart", DocumentPartView], ["model.parts.story.StoryPart", StoryPart], ["model.parts.hdrftr.HeaderPart", HeaderPart], ["model.parts.hdrftr.FooterPart", FooterPart], ["model.parts.comments.CommentsPart", CommentsPart]]) {
+  action(`${prefix2}.next_id.get`, owner, (receiver) => receiver.next_id);
+  action(`${prefix2}.get_style.call`, owner, (receiver, args) => receiver.get_style(args.styleId, args.styleType));
+  action(`${prefix2}.get_style_id.call`, owner, (receiver, args) => receiver.get_style_id(args.styleOrName, args.styleType));
+  for (const method of ["get_or_add_image", "new_pic_inline"]) packageActions.set(`${prefix2}.${method}.call`, async (receiver, args, context) => {
+    if (!(receiver instanceof owner)) throw new DocxUsageError("Expected an admitted native story owner.");
+    const descriptor = args.imageDescriptor;
+    const input = !(descriptor instanceof Uint8Array) && "path" in descriptor ? { path: descriptor.path, capability: descriptor.capability } : (await acquireImageModelInput(descriptor, context)).bytes;
+    return method === "new_pic_inline" ? receiver.new_pic_inline(input, args.width, args.height) : receiver.get_or_add_image(input);
+  });
+}
+action("model.parts.comments.CommentsPart.comments.get", CommentsPart, (receiver) => receiver.comments);
+action("model.parts.settings.SettingsPart.settings.get", SettingsPart, (receiver) => receiver.settings);
+for (const name of ["document", "comments", "settings", "styles", "inline_shapes", "core_properties"])
+  action(`model.parts.document.DocumentPart.${name}.get`, DocumentPartView, (receiver) => receiver[name]);
+action("model.parts.document.DocumentPart.numbering_part.get", DocumentPartView, (receiver) => receiver.numbering_part);
+for (const method of ["add_header_part", "add_footer_part"])
+  action(`model.parts.document.DocumentPart.${method}.call`, DocumentPartView, (receiver) => receiver[method]());
+for (const method of ["header_part", "footer_part", "drop_header_part"])
+  action(`model.parts.document.DocumentPart.${method}.call`, DocumentPartView, (receiver, args) => receiver[method](args.rId));
+action("model.parts.numbering.NumberingPart.numbering_definitions.get", NumberingPart, (receiver) => receiver.numbering_definitions);
+action("model.parts.numbering._NumberingDefinitions.__len__.get", _NumberingDefinitions, (receiver) => receiver.length);
+action("model.NumberingDefinitionsView.length.get", _NumberingDefinitions, (receiver) => receiver.length);
+packageActions.set("model.parts.numbering.NumberingPart.new.call", (_receiver, args) => NumberingPart.new(args.ownerPackage));
+var packageViewBatchActions = new Map(
+  Object.keys(docxOperationSchemas).flatMap((id) => {
+    const action2 = packageActions.get(id);
+    return action2 ? [[id, action2]] : [];
+  })
+);
+
+export {
+  packageViewBatchActions
+};

package/dist/safe-bash/command-chunks/chunk-IOSWG5JS.js

@@ -0,0 +1,228 @@
+import {
+  applyTableStructure,
+  validateTableStructureOperation
+} from "./chunk-7PZASWL6.js";
+import {
+  applyTableUpdate,
+  createTableXml,
+  readTable,
+  validateTableUpdate
+} from "./chunk-MQU6Q75R.js";
+import {
+  nodeFor,
+  selected
+} from "./chunk-QHS7PDG3.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  child,
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/table-operations.ts
+function tableCell(value) {
+  if (typeof value !== "string") throw new SelectionError("invalid-selection");
+  const parts = value.split(",");
+  if (parts.length !== 2 || parts.some(
+    (p) => !p.length || [...p].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(p)) || Number(p) < 1
+  ))
+    throw new SelectionError("invalid-selection");
+  return { row: Number(parts[0]) - 1, column: Number(parts[1]) - 1 };
+}
+function validateTableSelection(options, action) {
+  const allowed = [
+    "scope",
+    "slide",
+    "select",
+    "cell",
+    ...action === "add" ? [] : ["table"],
+    ...action === "read" ? [] : ["update"],
+    ...action === "set" ? ["all", "allowEmpty"] : []
+  ];
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (k) => typeof k !== "string" || !allowed.includes(k) || !("value" in Object.getOwnPropertyDescriptor(options, k))
+  ))
+    throw new OfficeError("invalid-value", "Invalid table selection options.", "usage");
+  for (const key of ["slide", "table"])
+    if (options[key] !== void 0 && (!Number.isSafeInteger(options[key]) || options[key] < 1))
+      throw new OfficeError(
+        "invalid-value",
+        "Table selectors require positive integer positions.",
+        "usage"
+      );
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      throw new OfficeError("invalid-value", "Table selection controls require booleans.", "usage");
+  if (options.scope !== void 0 && options.scope !== "slides")
+    throw new SelectionError("invalid-selection");
+  if (options.cell !== void 0) tableCell(options.cell);
+  if (options.select !== void 0 && (typeof options.select !== "string" || !options.select.length || options.slide !== void 0 || options.table !== void 0 || options.cell !== void 0 || options.all !== void 0))
+    throw new SelectionError("invalid-selection");
+}
+function tableRecords(s, options) {
+  const records = selected(s, {
+    ...options.scope === void 0 ? {} : { scope: options.scope },
+    ...options.slide === void 0 ? {} : { slide: options.slide },
+    ...options.select === void 0 ? {} : { select: options.select }
+  });
+  const positions = /* @__PURE__ */ new Map();
+  const parts = new Set(records.map((r) => r.part));
+  const documents = /* @__PURE__ */ new Map();
+  const all = s.index.objects.filter((r) => {
+    if (!parts.has(r.part)) return false;
+    let doc = documents.get(r.part);
+    if (!doc) {
+      doc = s.doc(r.part);
+      documents.set(r.part, doc);
+    }
+    const node = nodeFor(doc.root, r.id);
+    const graphic = node.children.find(
+      (n) => n.name.localName === "graphic" && n.name.namespace === s.a
+    );
+    return node.name.localName === "graphicFrame" && !!graphic && !!child(required(graphic, "graphicData"), "tbl");
+  });
+  const ordinal = /* @__PURE__ */ new Map();
+  for (const r of all) {
+    const n = (positions.get(r.part) ?? 0) + 1;
+    positions.set(r.part, n);
+    ordinal.set(r, n);
+  }
+  return records.filter(
+    (r) => ordinal.has(r) && (options.table === void 0 || ordinal.get(r) === options.table)
+  );
+}
+function count(records, options) {
+  if (!options.select && options.slide === void 0 && options.table === void 0 && !options.all)
+    throw new SelectionError("invalid-selection");
+  if (!records.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((r) => r.location)
+    );
+}
+async function readTables(input, options, context) {
+  validateTableSelection(options, "read");
+  const s = await loadShared(input, context, false);
+  return tableRecords(s, options).map((r) => {
+    const doc = s.doc(r.part), record = readTable(nodeFor(doc.root, r.id), doc);
+    if (options.cell !== void 0) {
+      const c = tableCell(options.cell);
+      if (c.row >= record.rows || c.column >= record.columns)
+        throw new SelectionError("missing-selection");
+    }
+    return { ...record, location: r.location, token: r.token, part: r.part };
+  });
+}
+function selectedUpdate(options, creating = false) {
+  if (!options.update || typeof options.update !== "object" || Reflect.ownKeys(options.update).some(
+    (k) => typeof k !== "string" || !("value" in Object.getOwnPropertyDescriptor(options.update, k))
+  ))
+    throw new OfficeError("invalid-value", "Table updates require stored data.", "usage");
+  if (!creating && !Object.keys(options.update).some((k) => options.update[k] !== void 0))
+    throw new OfficeError("invalid-value", "A table edit is required.", "usage");
+  if (options.update.cell !== void 0)
+    throw new OfficeError(
+      "invalid-value",
+      "Use the table cell selector for package edits.",
+      "usage"
+    );
+  const update = {
+    ...options.update,
+    ...options.cell === void 0 ? {} : { cell: tableCell(options.cell) }
+  };
+  validateTableUpdate(update, creating);
+  return update;
+}
+async function addTable(input, options, context) {
+  validateTableSelection(options, "add");
+  const update = selectedUpdate(options, true);
+  const cells = options.update.rows * options.update.columns;
+  if (cells > Math.floor(context.xmlLimits.maxNodes / 5))
+    throw new OfficeError("resource-limit", "Table grid exceeds XML node budget.", "usage");
+  const s = await loadShared(input, context), records = selected(s, options, true);
+  if (records.length !== 1)
+    throw new SelectionError(records.length ? "ambiguous-selection" : "missing-selection");
+  const record = records[0], doc = s.doc(record.part), tree = required(required(doc.root, "cSld"), "spTree");
+  const id = new ShapeIdAllocator(() => doc).next();
+  const ext = child(tree, "extLst");
+  s.save(
+    record.part,
+    doc.spliceChildren(tree, ext ? tree.children.indexOf(ext) : tree.children.length, 0, [
+      createTableXml(id, update, s.p)
+    ])
+  );
+  return {
+    ...await s.finish(
+      record.part,
+      s.index.inventory.slides.filter((x) => x.part === record.part).map((x) => x.position)
+    ),
+    affected: 1,
+    records: [{ ...record, id: String(id) }]
+  };
+}
+async function mutateTables(input, options, context) {
+  validateTableSelection(options, "set");
+  const update = selectedUpdate(options);
+  return editTables(input, options, context, update);
+}
+async function restructureTables(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ))
+    throw new OfficeError("invalid-value", "Structural options require stored data.", "usage");
+  const { operation, ...selection } = options;
+  validateTableStructureOperation(operation);
+  if (Object.hasOwn(selection, "update"))
+    throw new OfficeError(
+      "invalid-value",
+      "Formatting updates cannot be mixed with structural edits.",
+      "usage"
+    );
+  validateTableSelection(selection, "set");
+  if (selection.cell !== void 0) {
+    const cell = tableCell(selection.cell);
+    if (operation.kind !== "split" || operation.cell.row !== cell.row || operation.cell.column !== cell.column)
+      throw new OfficeError("invalid-value", "Cell selector must match the split origin.", "usage");
+  }
+  return editTables(input, selection, context, void 0, operation);
+}
+async function editTables(input, options, context, update, structure) {
+  const s = await loadShared(input, context), records = tableRecords(s, options);
+  count(records, options);
+  for (const r of records) {
+    const doc = s.doc(r.part);
+    s.save(
+      r.part,
+      structure ? applyTableStructure(doc, nodeFor(doc.root, r.id), structure) : applyTableUpdate(doc, nodeFor(doc.root, r.id), update)
+    );
+  }
+  const part = records[0]?.part ?? s.main;
+  const affectedSlides = s.index.inventory.slides.filter((x) => records.some((r) => r.part === x.part)).map((x) => x.position);
+  const unchanged = [...s.changes].every(([name, bytes]) => {
+    const original = s.reader.get(name);
+    return bytes.length === original.length && bytes.every((value, i) => value === original[i]);
+  });
+  return {
+    ...unchanged ? { bytes: s.source, part, affectedSlides } : await s.finish(part, affectedSlides),
+    affected: records.length,
+    records
+  };
+}
+
+export {
+  tableCell,
+  validateTableSelection,
+  readTables,
+  addTable,
+  mutateTables,
+  restructureTables
+};