@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,207 @@
+import {
+  dashPresets,
+  patternPresets
+} from "./chunk-A3XE767Q.js";
+import {
+  themeColorSlots
+} from "./chunk-LHRXDH45.js";
+
+// packages/safe-bash-presentation-engine/src/drawing-schema.ts
+var ratio = { type: "number", minimum: 0, maximum: 1 };
+var rgb = { type: "string", pattern: "^[0-9A-Fa-f]{6}$" };
+var drawingColorSchema = {
+  anyOf: [
+    rgb,
+    ...["rgb", "theme"].map((key) => ({
+      type: "object",
+      additionalProperties: false,
+      required: [key],
+      properties: {
+        [key]: key === "rgb" ? rgb : { enum: [...themeColorSlots, "tx1", "tx2", "bg1", "bg2", "phClr"] },
+        brightness: { type: "number", minimum: -1, maximum: 1 },
+        opacity: ratio
+      }
+    }))
+  ]
+};
+var length = {
+  type: "object",
+  additionalProperties: false,
+  required: ["value", "unit"],
+  properties: {
+    value: { type: "number", minimum: 0 },
+    unit: { enum: ["emu", "in", "cm", "mm", "pt"] }
+  }
+};
+var fill = {
+  oneOf: [
+    ...["inherit", "none"].map((kind) => ({
+      type: "object",
+      additionalProperties: false,
+      required: ["kind"],
+      properties: { kind: { const: kind } }
+    })),
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind"],
+      properties: { kind: { const: "solid" }, color: drawingColorSchema }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "stops", "angle"],
+      properties: {
+        kind: { const: "gradient" },
+        angle: { type: "number", minimum: -36e4, maximum: 36e4 },
+        stops: {
+          type: "array",
+          minItems: 2,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["position", "color"],
+            properties: { position: ratio, color: drawingColorSchema }
+          }
+        }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "preset"],
+      properties: {
+        kind: { const: "pattern" },
+        preset: { enum: patternPresets },
+        foreground: drawingColorSchema,
+        background: drawingColorSchema
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "mode"],
+      properties: {
+        kind: { const: "picture" },
+        relationshipId: { type: "string", minLength: 1 },
+        mode: { enum: ["stretch", "tile"] },
+        crop: {
+          type: "object",
+          additionalProperties: false,
+          required: ["left", "top", "right", "bottom"],
+          properties: { left: ratio, top: ratio, right: ratio, bottom: ratio }
+        }
+      }
+    }
+  ]
+};
+var drawingUpdateSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    fill,
+    line: {
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        fill,
+        width: { anyOf: [length, { type: "null" }] },
+        dash: { enum: [...dashPresets, null] }
+      }
+    },
+    shadowInherit: { type: "boolean" },
+    shadow: {
+      anyOf: [
+        { type: "null" },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["blur", "color", "opacity"],
+          properties: { blur: length, color: drawingColorSchema, opacity: ratio }
+        }
+      ]
+    }
+  },
+  minProperties: 1,
+  not: { required: ["shadow", "shadowInherit"] }
+};
+var drawingSchemaDefinitions = Object.fromEntries(
+  ["shapes.drawing.get", "shapes.drawing.set", "shapes.effects.set"].map((operation) => {
+    const mutation = operation.endsWith(".set"), effects = operation === "shapes.effects.set";
+    return [
+      operation,
+      {
+        description: "Local drawing fills, lines, alpha and zero-offset outer shadows; theme colors remain references. Complex effects and 3D are preserve-only.",
+        input: { type: "string", minLength: 1 },
+        options: {
+          type: "object",
+          additionalProperties: false,
+          ...effects ? { required: ["shadow", "opacity", "shadowBlur", "shadowColor"] } : {},
+          properties: {
+            json: { type: "boolean" },
+            limit: { type: "object" },
+            scope: { enum: ["slides", "layouts", "masters", "shared"] },
+            slide: { type: "integer", minimum: 1 },
+            part: { type: "string" },
+            select: { type: "string" },
+            shape: { type: "string" },
+            ...mutation ? {
+              output: { type: "string" },
+              inPlace: { type: "boolean" },
+              force: { type: "boolean" },
+              dryRun: { type: "boolean" },
+              all: { type: "boolean" },
+              allowEmpty: { type: "boolean" },
+              ...effects ? {
+                shadow: { type: "boolean" },
+                opacity: ratio,
+                shadowBlur: length,
+                shadowColor: drawingColorSchema
+              } : {
+                fill,
+                fillKind: {
+                  enum: ["inherit", "none", "solid", "gradient", "pattern", "picture"]
+                },
+                color: drawingColorSchema,
+                stops: {
+                  type: "array",
+                  minItems: 2,
+                  items: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["position", "color"],
+                    properties: { position: ratio, color: drawingColorSchema }
+                  }
+                },
+                angle: { type: "number", minimum: -36e4, maximum: 36e4 },
+                pattern: { enum: patternPresets },
+                mode: { enum: ["stretch", "tile"] },
+                foreground: drawingColorSchema,
+                background: drawingColorSchema,
+                file: { type: "string", minLength: 1 },
+                line: {
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    fill,
+                    width: { anyOf: [length, { type: "null" }] },
+                    dash: { enum: [...dashPresets, null] }
+                  }
+                },
+                shadowInherit: { type: "boolean" }
+              }
+            } : {}
+          }
+        },
+        result: {}
+      }
+    ];
+  })
+);
+
+export {
+  drawingColorSchema,
+  drawingUpdateSchema,
+  drawingSchemaDefinitions
+};

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

@@ -0,0 +1,260 @@
+import {
+  attr,
+  child,
+  invalid,
+  loadShared
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/transitions.ts
+import { SaxesParser } from "saxes";
+var durationNamespace = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var compatibilityNamespace = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var directions = { left: "l", right: "r", up: "u", down: "d" };
+var kinds = ["cut", "fade", "push", "wipe"];
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Unsupported transition content is preserve-only.",
+    "validate-intent"
+  );
+}
+function milliseconds(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 2147483647)
+    invalid("Transition times must be integer milliseconds in 0..2147483647.");
+}
+function validateTransitionOptions(action, options) {
+  if (!["add", "set", "remove"].includes(action) || !options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (k) => ![
+      "selection",
+      "kind",
+      "direction",
+      "duration",
+      "advanceAfter",
+      "advanceOnClick",
+      "allowEmpty"
+    ].includes(k)
+  ))
+    invalid("Invalid transition options.");
+  if (action === "set" && [
+    options.kind,
+    options.direction,
+    options.duration,
+    options.advanceAfter,
+    options.advanceOnClick
+  ].every((v) => v === void 0))
+    invalid("Setting a transition requires an update.");
+  if (options.kind !== void 0 && !kinds.includes(options.kind))
+    invalid("Unsupported transition kind.");
+  if (action === "add" && options.kind === void 0)
+    invalid("Adding a transition requires a kind.");
+  if (action === "remove" && [
+    options.kind,
+    options.direction,
+    options.duration,
+    options.advanceAfter,
+    options.advanceOnClick
+  ].some((v) => v !== void 0))
+    invalid("Removal accepts no transition settings.");
+  if (options.direction !== void 0 && (typeof options.direction !== "string" || !Object.hasOwn(directions, options.direction)))
+    invalid("Invalid transition direction.");
+  if (options.duration !== void 0) milliseconds(options.duration);
+  if (options.advanceAfter !== void 0 && options.advanceAfter !== null)
+    milliseconds(options.advanceAfter);
+  if (options.advanceOnClick !== void 0 && typeof options.advanceOnClick !== "boolean")
+    invalid("Click advance requires a boolean.");
+  if (options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean")
+    invalid("allowEmpty requires a boolean.");
+  if ((options.kind === "cut" || options.kind === "fade") && options.direction !== void 0)
+    invalid("Cut and fade forbid direction.");
+  if ((options.kind === "push" || options.kind === "wipe") && options.direction === void 0)
+    invalid("Push and wipe require direction.");
+  if (options.kind === "cut" && options.duration !== void 0 && options.duration !== 0)
+    invalid("Cut duration must be zero.");
+}
+function transition(doc) {
+  if (doc.root.children.filter(
+    (n) => n.name.namespace === doc.root.name.namespace && n.name.localName === "transition"
+  ).length > 1)
+    throw new OfficeError("invalid-xml", "Multiple slide transitions.", "parse");
+  const direct = child(doc.root, "transition");
+  const wrapped = doc.root.children.some(
+    (n) => n !== direct && n.name.localName !== "cSld" && containsTransition(n, doc.root.name.namespace)
+  );
+  return { direct, wrapped };
+}
+function containsTransition(node, ns) {
+  return node.name.namespace === ns && node.name.localName === "transition" || node.children.some((n) => containsTransition(n, ns));
+}
+function effectKind(node) {
+  if (node.attributes.some(
+    (a) => !(a.name.namespace === "" && ["advTm", "advClick", "spd"].includes(a.name.localName) || a.name.namespace === durationNamespace && a.name.localName === "dur" || a.name.namespace === compatibilityNamespace)
+  ) || node.children.filter(
+    (n) => n.name.namespace === node.name.namespace && n.name.localName === "sndAc"
+  ).length > 1)
+    return "unsupported";
+  const effects = node.children.filter(
+    (n) => n.name.namespace !== node.name.namespace || n.name.localName !== "sndAc"
+  );
+  const effect = effects[0];
+  if (effects.length !== 1 || !effect || effect.name.namespace !== node.name.namespace || !kinds.includes(effect.name.localName) || effect.children.length)
+    return "unsupported";
+  const kind = effect.name.localName;
+  if (effect.attributes.some(
+    (a) => a.name.namespace !== "" || !(kind === "push" || kind === "wipe" ? a.name.localName === "dir" && Object.values(directions).includes(a.value) : a.name.localName === "thruBlk" && ["0", "false"].includes(a.value))
+  ))
+    return "unsupported";
+  return kind;
+}
+function record(doc, selected) {
+  const { direct: node, wrapped } = transition(doc), kind = wrapped ? "unsupported" : node ? effectKind(node) : null;
+  const effect = node?.children.find(
+    (n) => n.name.localName === kind && n.name.namespace === node.name.namespace
+  );
+  const dir = effect ? attr(effect, "dir") : void 0;
+  const duration = node?.attributes.find(
+    (a) => a.name.namespace === durationNamespace && a.name.localName === "dur"
+  )?.value;
+  for (const value of [duration, node && attr(node, "advTm")])
+    if (value !== void 0 && (value.trim() === "" || ![...value.trim().startsWith("+") ? value.trim().slice(1) : value.trim()].every(
+      (c) => c >= "0" && c <= "9"
+    ) || !Number.isInteger(Number(value)) || Number(value) < 0 || Number(value) > 2147483647))
+      throw new OfficeError("invalid-xml", "Invalid transition millisecond metadata.", "parse");
+  if (node && attr(node, "advClick") !== void 0 && !["0", "1", "true", "false"].includes(attr(node, "advClick")))
+    throw new OfficeError("invalid-xml", "Invalid transition click metadata.", "parse");
+  return {
+    selector: selected.token,
+    location: selected.location,
+    slide: selected.position,
+    part: selected.part,
+    kind,
+    direction: kind === "push" || kind === "wipe" ? Object.entries(directions).find(
+      ([, v]) => v === (dir ?? "l")
+    )?.[0] ?? null : null,
+    duration: kind === "cut" ? 0 : duration === void 0 ? null : Number(duration),
+    advanceAfter: node && attr(node, "advTm") !== void 0 ? Number(attr(node, "advTm")) : null,
+    advanceOnClick: node ? !["0", "false"].includes(attr(node, "advClick") ?? "true") : null
+  };
+}
+function selectedSlides(s, selection) {
+  const selected = s.index.select({ ...selection, kind: selection.kind ?? "slide" });
+  if (selected.some((n) => n.kind !== "slide")) throw new SelectionError("invalid-selection");
+  return selected;
+}
+async function readTransitions(input, options, context) {
+  if (!options || Object.keys(options).some((k) => k !== "selection"))
+    invalid("Invalid transition query.");
+  const s = await loadShared(input, context, false);
+  const selected = options.selection ? selectedSlides(s, options.selection) : s.index.slides;
+  return selected.map((n) => record(s.doc(n.part), n));
+}
+function exactDuration(doc, duration) {
+  let node = child(doc.root, "transition");
+  doc = doc.merge(node, {
+    attributes: [{ namespace: durationNamespace, localName: "dur", value: String(duration) }]
+  });
+  node = child(doc.root, "transition");
+  let prefix = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentag", (tag) => {
+    if (tag.local === "transition" && tag.uri === node.name.namespace)
+      prefix = Object.values(tag.attributes).find((a) => a.uri === durationNamespace && a.local === "dur")?.prefix ?? "";
+  });
+  parser.write(doc.markup(node, true)).close();
+  const existing = node.attributes.find(
+    (a) => a.name.namespace === compatibilityNamespace && a.name.localName === "Ignorable"
+  )?.value ?? "";
+  return doc.merge(node, {
+    attributes: [
+      {
+        namespace: compatibilityNamespace,
+        localName: "Ignorable",
+        value: [...new Set(`${existing} ${prefix}`.split(" ").filter(Boolean))].join(" ")
+      }
+    ]
+  });
+}
+async function mutateTransitions(input, action, options, context) {
+  validateTransitionOptions(action, options);
+  if (!options.selection) throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context);
+  let selected;
+  try {
+    selected = selectedSlides(s, options.selection);
+  } catch (error) {
+    if (!(error instanceof SelectionError) || error.code !== "missing-selection" || !options.allowEmpty)
+      throw error;
+    selected = [];
+  }
+  if (action === "add" && selected.length > 1) throw new SelectionError("ambiguous-selection");
+  const affected = [];
+  for (const slide of selected) {
+    let doc = s.doc(slide.part);
+    const { direct, wrapped } = transition(doc);
+    let node = direct;
+    if (wrapped || node && effectKind(node) === "unsupported") unsupported();
+    if (action === "add" && node) invalid("A transition already exists.");
+    if (action === "remove") {
+      if (!node) continue;
+      affected.push(slide.position);
+      if (node) doc = doc.spliceChildren(doc.root, doc.root.children.indexOf(node), 1, []);
+      s.save(slide.part, doc);
+      continue;
+    }
+    const current = record(doc, slide), kind = options.kind ?? current.kind;
+    if (!kind || kind === "unsupported") invalid("Creating a transition requires a kind.");
+    const directional = kind === "push" || kind === "wipe";
+    const direction = options.direction ?? (directional && current.kind === kind ? current.direction : void 0);
+    if (directional && !direction || !directional && options.direction !== void 0)
+      invalid("Transition direction conflicts with its kind.");
+    if (kind === "cut" && options.duration !== void 0 && options.duration !== 0)
+      invalid("Cut duration must be zero.");
+    const duration = kind === "cut" ? 0 : options.duration ?? (!node || current.kind === "cut" ? 500 : void 0);
+    if (!node) {
+      const before = doc.root.children.findIndex(
+        (n) => n.name.namespace === s.p && ["timing", "extLst"].includes(n.name.localName)
+      );
+      doc = doc.spliceChildren(doc.root, before < 0 ? doc.root.children.length : before, 0, [
+        `<p:transition xmlns:p="${s.p}" advClick="1"/>`
+      ]);
+      node = child(doc.root, "transition");
+    }
+    if (options.kind !== void 0 || options.direction !== void 0 || !node.children.length) {
+      const effect = node.children.find(
+        (n) => n.name.namespace === s.p && kinds.includes(n.name.localName)
+      );
+      doc = doc.spliceChildren(node, effect ? node.children.indexOf(effect) : 0, effect ? 1 : 0, [
+        `<p:${kind} xmlns:p="${s.p}"${directional ? ` dir="${directions[direction]}"` : ""}/>`
+      ]);
+      node = child(doc.root, "transition");
+    }
+    doc = doc.merge(node, {
+      attributes: [
+        ...options.advanceAfter === void 0 ? [] : [
+          {
+            namespace: "",
+            localName: "advTm",
+            value: options.advanceAfter === null ? null : String(options.advanceAfter)
+          }
+        ],
+        ...options.advanceOnClick === void 0 ? [] : [{ namespace: "", localName: "advClick", value: options.advanceOnClick ? "1" : "0" }]
+      ]
+    });
+    if (duration !== void 0) doc = exactDuration(doc, duration);
+    s.save(slide.part, doc);
+    affected.push(slide.position);
+  }
+  if (!affected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  return s.finish(selected[0]?.part ?? s.main, affected);
+}
+
+export {
+  validateTransitionOptions,
+  readTransitions,
+  mutateTransitions
+};

package/dist/safe-bash/command-chunks/{chunk-AHD3CGAY.js → chunk-AFPXADZG.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-JUTVKP5R.js";
 import {
   withSignal
-} from "./chunk-OOB7YCFQ.js";
-import {
-  scheduleNetworkDeadline
-} from "./chunk-3CDNIV7C.js";
+} from "./chunk-FMJKCVSQ.js";
 import {
   CurlError
 } from "./chunk-QYXWTNUN.js";
+import {
+  scheduleNetworkDeadline
+} from "./chunk-3CDNIV7C.js";
 
 // packages/safe-bash-network-engine/src/fetch-transport.ts
 function requestBody(source, signal) {