@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-kvp4ttef.js

@@ -0,0 +1,307 @@
+import {
+  catchError
+} from "./packager-tool-wv85dhy2.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/sdd-convert/canvas-note-match.ts
+var SIMILAR = 0.5;
+var UNSPACED = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+/gu;
+var words = (text) => {
+  const lower = text.toLowerCase();
+  const tokens = new Set(lower.replace(UNSPACED, " ").match(/[\p{L}\p{N}]+/gu) ?? []);
+  for (const run of lower.match(UNSPACED) ?? []) {
+    const chars = [...run];
+    if (chars.length === 1)
+      tokens.add(run);
+    for (let at = 0;at + 1 < chars.length; at += 1)
+      tokens.add(chars[at] + chars[at + 1]);
+  }
+  return tokens;
+};
+var similarity = (a, b) => {
+  const left = words(a);
+  const right = words(b);
+  const shared = [...left].filter((word) => right.has(word)).length;
+  const all = new Set([...left, ...right]).size;
+  return all === 0 ? 0 : shared / all;
+};
+var commonRun = (a, b) => {
+  const length = a.map(() => new Array(b.length + 1).fill(0));
+  length.push(new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1;i2 >= 0; i2 -= 1)
+    for (let j2 = b.length - 1;j2 >= 0; j2 -= 1)
+      length[i2][j2] = a[i2] === b[j2] ? length[i2 + 1][j2 + 1] + 1 : Math.max(length[i2 + 1][j2], length[i2][j2 + 1]);
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      pairs.push([i, j]);
+      i += 1;
+      j += 1;
+    } else if (length[i + 1][j] >= length[i][j + 1])
+      i += 1;
+    else
+      j += 1;
+  }
+  return pairs;
+};
+var inOrder = (pairs) => {
+  const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+  const length = sorted.map(() => 1);
+  const before = sorted.map(() => -1);
+  for (let i = 0;i < sorted.length; i += 1)
+    for (let j = 0;j < i; j += 1)
+      if (sorted[j][1] < sorted[i][1] && length[j] + 1 > length[i]) {
+        length[i] = length[j] + 1;
+        before[i] = j;
+      }
+  let at = length.indexOf(Math.max(0, ...length));
+  const chain = [];
+  for (;at !== -1; at = before[at])
+    chain.unshift(sorted[at]);
+  return chain;
+};
+var runsOf = (left) => {
+  const runs = [];
+  for (const at of left) {
+    const last = runs.at(-1);
+    if (last !== undefined && last.after === at) {
+      last.at.push(at);
+      last.after = at + 1;
+    } else
+      runs.push({ at: [at], before: at - 1, after: at + 1 });
+  }
+  return runs;
+};
+var pairEdits = (rows, notes, textOf, into) => {
+  const candidates = rows.flatMap((row, r) => notes.map((note, n) => ({
+    r,
+    n,
+    score: similarity(textOf(row), textOf(note))
+  }))).filter((pair) => pair.score >= SIMILAR).sort((a, b) => b.score - a.score || a.r - b.r || a.n - b.n);
+  const rowTaken = new Set;
+  const noteTaken = new Set;
+  const pairs = [];
+  for (const { r, n } of candidates) {
+    if (rowTaken.has(r) || noteTaken.has(n))
+      continue;
+    rowTaken.add(r);
+    noteTaken.add(n);
+    pairs.push([r, n]);
+  }
+  const restRows = rows.flatMap((_, r) => rowTaken.has(r) ? [] : [r]);
+  const restNotes = notes.flatMap((_, n) => noteTaken.has(n) ? [] : [n]);
+  pairs.sort((a, b) => a[0] - b[0]);
+  for (const [r, n] of pairs)
+    into.changed.push([rows[r], notes[n]]);
+  for (const r of restRows)
+    into.added.push(rows[r]);
+  for (const n of restNotes)
+    into.removed.push(notes[n]);
+};
+var matchNotes = (rows, notes, keyOf, textOf, idOf) => {
+  const match = {
+    same: [],
+    changed: [],
+    added: [],
+    removed: []
+  };
+  const rowTaken = new Set;
+  const noteTaken = new Set;
+  const anchors = [];
+  const pairsAt = [];
+  const take = (r, n, anchor) => {
+    rowTaken.add(r);
+    noteTaken.add(n);
+    pairsAt.push([r, n]);
+    match.same.push([rows[r], notes[n]]);
+    if (anchor)
+      anchors.push([r, n]);
+  };
+  rows.forEach((row, r) => {
+    const n = notes.findIndex((note, at) => !noteTaken.has(at) && idOf(note) === idOf(row) && keyOf(note) === keyOf(row));
+    if (n !== -1)
+      take(r, n, true);
+  });
+  const fixed = inOrder(anchors);
+  let fromRow = 0;
+  let fromNote = 0;
+  for (const [toRow, toNote] of [
+    ...fixed,
+    [rows.length, notes.length]
+  ]) {
+    const stretchRows = [];
+    for (let r = fromRow;r < toRow; r += 1)
+      if (!rowTaken.has(r))
+        stretchRows.push(r);
+    const stretchNotes = [];
+    for (let n = fromNote;n < toNote; n += 1)
+      if (!noteTaken.has(n))
+        stretchNotes.push(n);
+    for (const [a, b] of commonRun(stretchRows.map((r) => keyOf(rows[r])), stretchNotes.map((n) => keyOf(notes[n]))))
+      take(stretchRows[a], stretchNotes[b], true);
+    fromRow = toRow + 1;
+    fromNote = toNote + 1;
+  }
+  rows.forEach((row, r) => {
+    if (rowTaken.has(r))
+      return;
+    const n = notes.findIndex((note, at) => !noteTaken.has(at) && keyOf(note) === keyOf(row));
+    if (n !== -1)
+      take(r, n, false);
+  });
+  const refText = (ref) => textOf(ref.item);
+  const byWords = {
+    same: [],
+    changed: [],
+    added: [],
+    removed: []
+  };
+  pairEdits(rows.flatMap((item, at) => rowTaken.has(at) ? [] : [{ at, item }]), notes.flatMap((item, at) => noteTaken.has(at) ? [] : [{ at, item }]), refText, byWords);
+  const partner = new Map(pairsAt);
+  for (const [row, note] of byWords.changed) {
+    match.changed.push([row.item, note.item]);
+    partner.set(row.at, note.at);
+  }
+  const byAt = (refs) => refs.map((ref) => ref.at).sort((x, y) => x - y);
+  const rowRuns = runsOf(byAt(byWords.added));
+  const noteRuns = runsOf(byAt(byWords.removed));
+  const neighbours = (row, note) => row === -1 || row === rows.length ? note === (row === -1 ? -1 : notes.length) : partner.get(row) === note;
+  const used = new Set;
+  for (const run of rowRuns) {
+    const k = noteRuns.findIndex((other, at) => !used.has(at) && other.at.length === run.at.length && (neighbours(run.before, other.before) || neighbours(run.after, other.after)));
+    if (k === -1) {
+      match.added.push(...run.at.map((at) => rows[at]));
+      continue;
+    }
+    used.add(k);
+    for (const [i, at] of run.at.entries())
+      match.changed.push([rows[at], notes[noteRuns[k].at[i]]]);
+  }
+  noteRuns.forEach((run, k) => {
+    if (!used.has(k))
+      match.removed.push(...run.at.map((at) => notes[at]));
+  });
+  return match;
+};
+
+// ../case-tool/src/services/sdd-convert/canvas-notes.ts
+var STICKY_NOTE_TYPE = "case-management:StickyNote";
+var ROOT_PARENT = { id: "root", type: "case-management:root" };
+var SDD_NOTE_PREFIX = "StickyNote_sdd_";
+var DETACHED_NOTE_PREFIX = "StickyNote_detached_";
+var sddNoteId = (row) => `${SDD_NOTE_PREFIX}${row}`;
+var isStickyNote = (node) => typeof node === "object" && node !== null && node.type === STICKY_NOTE_TYPE;
+var fromSdd = (note) => typeof note.id === "string" && note.id.startsWith(SDD_NOTE_PREFIX);
+var DEFAULT_COLOR = "yellow";
+var noteKey = (data) => `${typeof data.color === "string" ? data.color : DEFAULT_COLOR}\x01${typeof data.content === "string" ? data.content : ""}`;
+var dataOf = (note) => note.data ?? {};
+var nodesOf = (document) => {
+  const nodes = document?.nodes;
+  return Array.isArray(nodes) ? nodes : undefined;
+};
+var emitCanvasNotes = (document, notes) => {
+  const nodes = nodesOf(document);
+  if (nodes === undefined || notes === undefined)
+    return 0;
+  for (const note of notes) {
+    nodes.push({
+      id: sddNoteId(note.row),
+      type: STICKY_NOTE_TYPE,
+      data: {
+        parentElement: { ...ROOT_PARENT },
+        ...note.color !== undefined && { color: note.color },
+        content: note.content
+      }
+    });
+  }
+  return notes.length;
+};
+var carryCanvasNotes = (document, previous, unresolved = []) => {
+  const nodes = nodesOf(document);
+  const before = nodesOf(previous)?.filter(isStickyNote) ?? [];
+  if (nodes === undefined || before.length === 0)
+    return 0;
+  const carried = before.map((note) => structuredClone(note));
+  const rows = nodes.filter(isStickyNote);
+  const match = matchNotes(rows, carried.filter(fromSdd).sort((a, b) => rowOf(a) - rowOf(b)), (note) => noteKey(dataOf(note)), (note) => String(dataOf(note).content ?? ""), (note) => note.id);
+  for (const [row, note] of match.changed)
+    unresolved.push({
+      kind: "canvas-note",
+      where: `nodes[${String(row.id)}]`,
+      detail: `the Canvas Notes row for this note now reads "${String(dataOf(row).content)}"${colorText(row)}, and the plan's note reads "${String(dataOf(note).content)}"${colorText(note)}; the plan's note is kept, since it may hold an edit made in the Case Designer — change the row or the note so they agree`
+    });
+  for (const [row, note] of [...match.same, ...match.changed])
+    note.id = row.id;
+  const ids = new Set(carried.map((note) => note.id));
+  let detached = 1;
+  for (const note of match.removed) {
+    while (ids.has(`${DETACHED_NOTE_PREFIX}${detached}`))
+      detached += 1;
+    note.id = `${DETACHED_NOTE_PREFIX}${detached}`;
+    ids.add(note.id);
+    unresolved.push({
+      kind: "canvas-note",
+      where: `nodes[${String(note.id)}]`,
+      detail: `the plan has the note "${String(dataOf(note).content)}" from a Canvas Notes row the SDD no longer has; the note is kept on the canvas, no longer tied to a row — delete it in the Case Designer if the row was removed on purpose`
+    });
+  }
+  const fresh = new Set(skipCopied(match.added, carried));
+  const others = nodes.filter((node) => !isStickyNote(node) || fresh.has(node));
+  nodes.splice(0, nodes.length, ...others, ...carried);
+  return before.length;
+};
+var rowOf = (note) => {
+  if (!fromSdd(note))
+    return 0;
+  const row = Number(String(note.id).slice(SDD_NOTE_PREFIX.length));
+  return Number.isInteger(row) ? row : 0;
+};
+var skipCopied = (added, carried) => {
+  const copies = new Map;
+  for (const note of carried) {
+    if (fromSdd(note))
+      continue;
+    const key = noteKey(dataOf(note));
+    copies.set(key, (copies.get(key) ?? 0) + 1);
+  }
+  return added.filter((row) => {
+    const key = noteKey(dataOf(row));
+    const left = copies.get(key) ?? 0;
+    if (left === 0)
+      return true;
+    copies.set(key, left - 1);
+    return false;
+  });
+};
+var colorText = (note) => {
+  const color = dataOf(note).color;
+  return typeof color === "string" ? ` (${color})` : ` (${DEFAULT_COLOR}, the default)`;
+};
+var carryCanvasNotesFrom = async (document, out, unresolved) => {
+  const { getFileSystemAsync } = await import("./index-ngs0a2he.js");
+  const fs = await getFileSystemAsync();
+  if (!await fs.exists(out))
+    return 0;
+  const [readError, text] = await catchError(fs.readFile(out, "utf-8"));
+  if (readError || typeof text !== "string")
+    return {
+      error: `Could not read the plan at ${out} to keep its sticky notes: ${readError?.message ?? "it read as empty"}`
+    };
+  if (text.trim() === "")
+    return 0;
+  const json = text.replace(/^\uFEFF/, "");
+  const [parseError, previous] = await catchError(Promise.resolve().then(() => JSON.parse(json)));
+  if (parseError)
+    return {
+      error: `The plan at ${out} is not valid JSON, so its sticky notes cannot be kept: ${parseError.message}`
+    };
+  return carryCanvasNotes(document, previous, unresolved);
+};
+
+export { STICKY_NOTE_TYPE, sddNoteId, emitCanvasNotes, carryCanvasNotes, carryCanvasNotesFrom };
+
+//# debugId=55B1C90BCF0AD4BD64756E2164756E21