@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,409 @@
+import {
+  NumberingGraph,
+  listProperties
+} from "./chunk-W543LSYH.js";
+import {
+  Comment,
+  Comments,
+  DocumentView,
+  Drawing,
+  Hyperlink,
+  InlineShape,
+  InlineShapes,
+  Paragraph,
+  RenderedPageBreak,
+  Run,
+  Section,
+  Sections,
+  Settings,
+  Table,
+  _Cell,
+  _Column,
+  _Columns,
+  _Footer,
+  _Header,
+  _Row,
+  _Rows
+} from "./chunk-6PJIQEH4.js";
+import {
+  acquireImageModelInput
+} from "./chunk-A7EMM3SB.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertFormattingHistoryEditable,
+  formattedRunProperties,
+  paragraphProperties,
+  paragraphUnits,
+  replaceListPropertyXml,
+  runElementOpen
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  Length,
+  docxEnumCanonicalNames,
+  docxOperationSchemas,
+  enumFamilies,
+  isEnumMember,
+  isLength,
+  plainLength
+} from "./chunk-R4TYL2G6.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/list-levels.ts
+function setParagraphListLevels(owner, options) {
+  const { store } = owner, { budget } = store.context;
+  store.transaction(() => {
+    const archive = store.snapshot(), packageGraph = new DocumentPackage(archive, store.context.limits, budget);
+    const documentOwner = store.documentOwnerForStory(owner.ref.part), dialect = dialectForNamespace(store.xml(documentOwner).root.namespace);
+    const r = documentDialects[dialect].r, edges = packageGraph.relationships(documentOwner);
+    const related = (kind) => {
+      const found = edges.filter((edge) => edge.reltype === `${r}/${kind}`);
+      if (found.length > 1 || found[0]?.is_external) throw new UnsupportedEditError("Numbering and style ownership must be unambiguous and internal.");
+      return found[0]?.target_part;
+    };
+    const numbering = related("numbering"), styles = related("styles");
+    if (!numbering) throw new UnsupportedEditError("Advanced list levels require an existing numbering definition.");
+    const editor = new DocumentXmlEditor(numbering.bytes, {}, void 0, budget), graph = new NumberingGraph(editor, styles ? parseDocumentXml(styles.bytes, {}, budget).root : void 0, budget);
+    for (const member of archive.members) if (member.name.endsWith(".xml")) graph.reserve(parseDocumentXml(member.bytes, {}, budget).root);
+    graph.project(store.xml(owner.ref.part).root);
+    const node = store.node(owner.ref), binding = graph.paragraph(node);
+    if (!binding) throw new UnsupportedEditError("Advanced list levels require an existing list paragraph.");
+    const resolved = graph.resolve(binding.id);
+    if (!resolved.levels.has(binding.level)) throw new UnsupportedEditError("The selected numbering level has no definition.");
+    const id = graph.setLevels(resolved, options);
+    if (id === binding.id) return;
+    store.change(owner.ref.part, (xml) => {
+      const current = store.node(owner.ref), children = activeXmlChildren(xml, budget);
+      graph.project(xml.root);
+      assertFormattingHistoryEditable(xml.root, current, children, budget);
+      const props = graph.child(current, "pPr"), markup = listProperties(xml, props, id, binding.level, current.namespace, graph);
+      if (props) xml[replaceListPropertyXml](props, markup);
+      else xml.insertChildren(current, markup, current.children[0]);
+    });
+    store.setPart(numbering.partname, graph.flush());
+  });
+}
+
+// packages/safe-bash-docx-engine/src/structure-model-batch-operations.ts
+var structureModelBatchActions = /* @__PURE__ */ new Map();
+function register(key, owner, action) {
+  if (!(key in docxOperationSchemas)) return;
+  structureModelBatchActions.set(key, (receiver, args) => {
+    if (!(receiver instanceof owner()))
+      throw new DocxUsageError("The receiver does not support this model operation.");
+    return action(receiver, args);
+  });
+}
+register("lists.levels.set", () => Paragraph, (receiver, args) => setParagraphListLevels(receiver, args));
+for (const operation of ["paragraphs.format.set", "runs.fonts.set"]) {
+  register(operation, () => operation === "paragraphs.format.set" ? Paragraph : Run, (receiver, args) => {
+    const owner = receiver, budget = owner.store.context.budget;
+    owner.store.change(owner.ref.part, (xml) => {
+      const node = owner.store.node(owner.ref), children = activeXmlChildren(xml, budget);
+      assertFormattingHistoryEditable(xml.root, node, children, budget);
+      const name = node.localName + "Pr", props = children(node).find((child) => child.namespace === node.namespace && child.localName === name);
+      const paragraph = args;
+      const paragraphOptions = {
+        ...paragraph.borders === void 0 ? {} : { borders: paragraph.borders === null ? null : Object.fromEntries(Object.entries(paragraph.borders).map(([name2, border]) => [name2, { ...border, width: plainLength(border.width), ...border.space === void 0 ? {} : { space: plainLength(border.space) } }])) },
+        ...paragraph.shading === void 0 ? {} : { shading: paragraph.shading === null ? null : { ...paragraph.shading, color: paragraph.shading.color ?? "000000" } }
+      };
+      const properties = operation === "runs.fonts.set" ? formattedRunProperties(xml, node, {}, children, args) : paragraphProperties(xml, node, paragraphOptions, void 0, children);
+      if (properties === (props ? xml.sourceXml(props) : "")) return;
+      xml.replaceElement(node, props ? xml.sourceXml(node, /* @__PURE__ */ new Map([[props, properties]])) : runElementOpen(node) + properties + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`);
+    });
+  });
+}
+function surface(prefix, owner, read, write, methods) {
+  for (const name of [...read, "element", "part"])
+    register(`${prefix}.${name}.get`, owner, (receiver) => Reflect.get(receiver, name));
+  for (const name of write)
+    register(`${prefix}.${name}.set`, owner, (receiver, args) => {
+      const type = docxOperationSchemas[`${prefix}.${name}.set`].batchFields.value.type.split(" | ")[0];
+      const family = enumFamilies[docxEnumCanonicalNames[type] ?? type];
+      const value = args.value;
+      const assigned = family && value !== null && value !== void 0 && !isEnumMember(value) ? family.members[value.name] : value;
+      if (family && value !== null && value !== void 0 && assigned === void 0)
+        throw new DocxUsageError("Unknown enum value.");
+      if (!Reflect.set(receiver, name, assigned))
+        throw new DocxUsageError("The property is not writable.");
+    });
+  for (const name of methods) {
+    const key = `${prefix}.${name}.call`;
+    register(key, owner, (receiver, args) => {
+      const fields = Object.keys(docxOperationSchemas[key]?.batchFields ?? {});
+      const method = Reflect.get(receiver, name);
+      const values = fields.map((field) => {
+        const value = args[field];
+        const type = docxOperationSchemas[key].batchFields[field].type;
+        const family = enumFamilies[docxEnumCanonicalNames[type] ?? type];
+        if (family && value !== void 0 && value !== null && !isEnumMember(value)) {
+          const member = family.members[value.name];
+          if (!member) throw new DocxUsageError("Unknown enum value.");
+          return member;
+        }
+        if ((field === "width" || field === "height") && type === "Length" && value !== void 0 && value !== null && !isLength(value))
+          return Length(paragraphUnits(value, 1));
+        return value;
+      });
+      return Reflect.apply(method, receiver, values);
+    });
+  }
+  for (const name of ["__eq__", "__ne__"])
+    register(`${prefix}.${name}.call`, owner, (receiver, args) => {
+      const equals = Reflect.get(receiver, "equals");
+      const result = equals ? equals.call(receiver, args.other) : receiver === args.other;
+      return name === "__eq__" ? result : !result;
+    });
+}
+surface(
+  "model.document.Document",
+  () => DocumentView,
+  [
+    "paragraphs",
+    "tables",
+    "sections",
+    "comments",
+    "core_properties",
+    "styles",
+    "settings",
+    "inline_shapes"
+  ],
+  [],
+  [
+    "add_comment",
+    "add_paragraph",
+    "add_table",
+    "add_heading",
+    "add_page_break",
+    "add_section",
+    "add_picture",
+    "iter_inner_content"
+  ]
+);
+surface(
+  "model.settings.Settings",
+  () => Settings,
+  ["odd_and_even_pages_header_footer"],
+  ["odd_and_even_pages_header_footer"],
+  []
+);
+surface(
+  "model.text.paragraph.Paragraph",
+  () => Paragraph,
+  [
+    "alignment",
+    "style",
+    "text",
+    "runs",
+    "hyperlinks",
+    "rendered_page_breaks",
+    "contains_page_break",
+    "paragraph_format"
+  ],
+  ["alignment", "style", "text"],
+  ["add_run", "clear", "insert_paragraph_before", "iter_inner_content"]
+);
+surface(
+  "model.text.run.Run",
+  () => Run,
+  ["text", "font", "style", "bold", "italic", "underline", "contains_page_break"],
+  ["text", "style", "bold", "italic", "underline"],
+  ["add_break", "add_tab", "add_text", "clear", "mark_comment_range", "add_picture"]
+);
+register(
+  "model.text.run.Run.iter_inner_content.call",
+  () => Run,
+  (receiver) => [...receiver.iter_inner_content()]
+);
+surface(
+  "model.shape.InlineShape",
+  () => InlineShape,
+  ["width", "height", "type"],
+  ["width", "height"],
+  []
+);
+surface("model.drawing.Drawing", () => Drawing, ["has_picture", "image", "_drawing"], [], []);
+surface("model.shape.InlineShapes", () => InlineShapes, [], [], []);
+register(
+  "model.shape.InlineShapes.__len__.get",
+  () => InlineShapes,
+  (receiver) => receiver.length
+);
+register(
+  "model.shape.InlineShapes.__iter__.call",
+  () => InlineShapes,
+  (receiver) => [...receiver]
+);
+register(
+  "model.shape.InlineShapes.__getitem__.get",
+  () => InlineShapes,
+  (receiver, args) => receiver.at(args.index)
+);
+for (const [prefix, owner] of [
+  ["model.document.Document", () => DocumentView],
+  ["model.text.run.Run", () => Run]
+])
+  register(`${prefix}.add_picture.call`, owner, async (receiver, args) => {
+    const model = receiver;
+    const descriptor = args.input;
+    const input = descriptor instanceof Uint8Array ? descriptor : "path" in descriptor ? { path: descriptor.path, capability: descriptor.capability } : (await acquireImageModelInput(descriptor, model.store.context)).bytes;
+    return model.add_picture(
+      input,
+      args.width,
+      args.height
+    );
+  });
+surface(
+  "model.table.Table",
+  () => Table,
+  ["alignment", "autofit", "columns", "rows", "style", "table_direction"],
+  ["alignment", "autofit", "style", "table_direction"],
+  ["add_column", "add_row", "cell", "column_cells", "row_cells"]
+);
+surface(
+  "model.table._Cell",
+  () => _Cell,
+  ["grid_span", "paragraphs", "tables", "text", "vertical_alignment", "width", "table"],
+  ["text", "vertical_alignment", "width"],
+  ["add_paragraph", "add_table", "iter_inner_content", "merge"]
+);
+surface(
+  "model.table._Row",
+  () => _Row,
+  ["cells", "grid_cols_before", "grid_cols_after", "height", "height_rule"],
+  ["height", "height_rule"],
+  []
+);
+surface("model.table._Column", () => _Column, ["cells", "width"], ["width"], []);
+register(
+  "model.table.Table.table.get",
+  () => Table,
+  (receiver) => receiver.table
+);
+for (const [name, owner] of [
+  ["_Row", () => _Row],
+  ["_Column", () => _Column],
+  ["_Rows", () => _Rows],
+  ["_Columns", () => _Columns]
+])
+  register(
+    `model.table.${name}.table.get`,
+    owner,
+    (receiver) => Reflect.get(receiver, "table")
+  );
+var sectionValues = [
+  "bottom_margin",
+  "different_first_page_header_footer",
+  "footer_distance",
+  "gutter",
+  "header_distance",
+  "left_margin",
+  "orientation",
+  "page_height",
+  "page_width",
+  "right_margin",
+  "start_type",
+  "top_margin"
+];
+surface(
+  "model.section.Section",
+  () => Section,
+  [
+    ...sectionValues,
+    "even_page_footer",
+    "even_page_header",
+    "first_page_footer",
+    "first_page_header",
+    "footer",
+    "header"
+  ],
+  sectionValues,
+  ["iter_inner_content"]
+);
+for (const [name, owner] of [
+  ["_Header", () => _Header],
+  ["_Footer", () => _Footer]
+])
+  surface(
+    `model.section.${name}`,
+    owner,
+    ["is_linked_to_previous", "paragraphs", "tables"],
+    ["is_linked_to_previous"],
+    ["add_paragraph", "add_table", "iter_inner_content"]
+  );
+surface(
+  "model.comments.Comment",
+  () => Comment,
+  ["author", "comment_id", "initials", "paragraphs", "tables", "text", "timestamp"],
+  ["author", "initials"],
+  ["add_paragraph", "add_table", "iter_inner_content"]
+);
+surface("model.comments.Comments", () => Comments, [], [], ["add_comment", "get"]);
+surface(
+  "model.text.hyperlink.Hyperlink",
+  () => Hyperlink,
+  ["address", "fragment", "runs", "text", "url", "contains_page_break", "history"],
+  [],
+  []
+);
+surface(
+  "model.text.pagebreak.RenderedPageBreak",
+  () => RenderedPageBreak,
+  ["preceding_paragraph_fragment", "following_paragraph_fragment"],
+  [],
+  []
+);
+for (const [prefix, owner] of [
+  ["model.table._Rows", () => _Rows],
+  ["model.table._Columns", () => _Columns],
+  ["model.section.Sections", () => Sections],
+  ["model.comments.Comments", () => Comments]
+]) {
+  register(`${prefix}.__len__.get`, owner, (receiver) => Reflect.get(receiver, "length"));
+  register(`${prefix}.__iter__.call`, owner, (receiver) => [...receiver]);
+  if (prefix !== "model.comments.Comments") {
+    for (const suffix of ["get", "call"])
+      register(
+        `${prefix}.__getitem__.${suffix}`,
+        owner,
+        (receiver, args) => receiver.at(args.index)
+      );
+    register(
+      `${prefix}.__getitem__.slice`,
+      owner,
+      (receiver, args) => receiver.slice(
+        args.start,
+        args.end
+      )
+    );
+  }
+  register(`${prefix}.part.get`, owner, (receiver) => Reflect.get(receiver, "part"));
+}
+surface("model.section.Sections", () => Sections, [], [], ["count", "index"]);
+register(
+  "model.section.Sections.__contains__.call",
+  () => Sections,
+  (receiver, args) => receiver.count(args.value) > 0
+);
+register(
+  "model.section.Sections.__reversed__.call",
+  () => Sections,
+  (receiver) => [...receiver].reverse()
+);
+
+export {
+  structureModelBatchActions
+};