@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/authoring-x84r2a2j.js

@@ -0,0 +1,23 @@
+import"./packager-tool-vgrswa8p.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-8ed52y5r.js";
+import {
+  registerCheckCommand2,
+  registerCompileCommand2,
+  registerDecompileCommand2,
+  registerMergeCommand2
+} from "./packager-tool-8qypzm9v.js";
+import"./packager-tool-64r7e4ek.js";
+
+// src/commands/authoring.ts
+var registerFlowAuthoringCommands = (program) => {
+  registerCompileCommand2(program, "flow");
+  registerCheckCommand2(program, "flow");
+  registerDecompileCommand2(program, "flow");
+  registerMergeCommand2(program, "flow");
+};
+export {
+  registerFlowAuthoringCommands
+};
+
+//# debugId=3F2C2FD5258B84F264756E2164756E21

package/dist/binding-service-s0wvr2xm.js

@@ -0,0 +1,114 @@
+import"./packager-tool-fzgfb0jt.js";
+import {
+  createBinding2,
+  addBinding2
+} from "./packager-tool-2b0tn4p4.js";
+import"./packager-tool-ze3fnf3s.js";
+import {
+  allNodesOf
+} from "./packager-tool-mdf7bws6.js";
+import"./packager-tool-vgrswa8p.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-8ed52y5r.js";
+import {
+  readFlowWorkflow2,
+  writeFlowWorkflow2
+} from "./packager-tool-6jpvvxyb.js";
+import"./packager-tool-gdpw0daf.js";
+import"./packager-tool-kz3t4raw.js";
+import"./packager-tool-65yf8zqb.js";
+import"./packager-tool-1qg04b7q.js";
+import"./packager-tool-p123mtfx.js";
+import"./packager-tool-508ka40b.js";
+import"./packager-tool-jmrhzfyj.js";
+import"./packager-tool-xb16e3tz.js";
+import"./packager-tool-d07g2kpn.js";
+import"./packager-tool-a1h0q79w.js";
+import"./packager-tool-21t17xzz.js";
+import"./packager-tool-b2pkwwj1.js";
+import"./packager-tool-1rhch6b5.js";
+import"./packager-tool-8n4bdvke.js";
+import"./packager-tool-ac6rvny7.js";
+import {
+  collectNodeBindingResourceKeys2
+} from "./packager-tool-5dgpfh5e.js";
+import {
+  VALID_RESOURCE_TYPES
+} from "./packager-tool-k3egwd1m.js";
+import"./packager-tool-2sazb7th.js";
+import"./packager-tool-64r7e4ek.js";
+import"./packager-tool-8ba22j6n.js";
+import"./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
+import"./packager-tool-4zt1s51a.js";
+
+// src/services/binding-service.ts
+function toBindingSummary(binding) {
+  return {
+    id: binding.id,
+    name: binding.name,
+    type: binding.type,
+    resource: binding.resource,
+    resourceKey: binding.resourceKey,
+    default: binding.default,
+    propertyAttribute: binding.propertyAttribute,
+    resourceSubType: binding.resourceSubType
+  };
+}
+var listBindingsInFlow = async (filePath) => {
+  const { workflow } = await readFlowWorkflow2(filePath);
+  const rawBindings = workflow.bindings ?? [];
+  const bindings = rawBindings.map(toBindingSummary);
+  return { bindings, count: bindings.length };
+};
+var addBindingToFlow = async (filePath, name, resource, defaultValue, options = {}) => {
+  if (!VALID_RESOURCE_TYPES.includes(resource)) {
+    throw new Error(`Invalid resource type: "${resource}". Valid resource types: ${VALID_RESOURCE_TYPES.join(", ")}`);
+  }
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  const binding = createBinding2({
+    name,
+    value: defaultValue,
+    resource,
+    resourceKey: options.resourceKey,
+    propertyAttribute: options.propertyAttribute,
+    resourceSubType: options.resourceSubType
+  });
+  addBinding2(workflow, binding);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  const persisted = workflow.bindings.find((b) => b.name === binding.name && b.resource === binding.resource && b.resourceKey === binding.resourceKey && b.propertyAttribute === binding.propertyAttribute);
+  return { binding: toBindingSummary(persisted ?? binding) };
+};
+var deleteBindingFromFlow = async (filePath, resourceKey) => {
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  const bindings = workflow.bindings ?? [];
+  const matching = bindings.filter((b) => b.resourceKey === resourceKey);
+  if (matching.length === 0) {
+    const available = [...new Set(bindings.map((b) => b.resourceKey))].join(", ") || "(none)";
+    throw new Error(`No bindings found with resourceKey "${resourceKey}". Available resourceKeys: ${available}`);
+  }
+  const nodes = allNodesOf(workflow);
+  const definitions = workflow.definitions ?? [];
+  const referencingNodeIds = [];
+  for (const node of nodes) {
+    const refs = collectNodeBindingResourceKeys2(node, bindings, definitions);
+    if (refs.has(resourceKey)) {
+      referencingNodeIds.push(node.id);
+    }
+  }
+  if (referencingNodeIds.length > 0) {
+    throw new Error(`Cannot delete bindings with resourceKey "${resourceKey}": still referenced by nodes: ${referencingNodeIds.join(", ")}`);
+  }
+  workflow.bindings = bindings.filter((b) => b.resourceKey !== resourceKey);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  const deletedBindings = matching.map(toBindingSummary);
+  return { deletedBindings, count: deletedBindings.length };
+};
+export {
+  addBindingToFlow,
+  deleteBindingFromFlow,
+  listBindingsInFlow
+};
+
+//# debugId=B50E4FE672A0DD1D64756E2164756E21

package/dist/{browser-strategy-6atc7v8s.js → browser-strategy-gnftxwsf.js}

@@ -1,10 +1,9 @@
-import {
-  getGlobalThis
-} from "./packager-tool-0gctz400.js";
 import {
   AUTH_CANCELLED_ERROR_CODE
-} from "./packager-tool-yc4kw997.js";
-import"./packager-tool-1yh8g550.js";
+} from "./packager-tool-1qg04b7q.js";
+import {
+  getGlobalThis
+} from "./packager-tool-zdqbp34f.js";
 
 // ../auth/src/strategies/browser-strategy.ts
 class BrowserAuthStrategy {
@@ -96,4 +95,4 @@ export {
   BrowserAuthStrategy
 };
 
-//# debugId=B13A3005E9EE6C6564756E2164756E21
+//# debugId=65561DFA5EC07C3664756E2164756E21

package/dist/connector-library-1yw5r47w.js

@@ -0,0 +1,99 @@
+// ../builder-sdk/src/connector-library.ts
+var FLOW_SDK_LIBRARY_URL = "https://download.uipath.com/maestro/registry/library-json.zip";
+var MOUNT_PATH = "/library";
+var LIBRARY_JSON = `${MOUNT_PATH}/integrations/library-json`;
+var READ_TEXT_SLOT = "uipath.maestro-builder-sdk.readText";
+
+class ConnectorLibraryError extends Error {
+  errorCode;
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+  }
+}
+function createConnectorLibraryLoader(deps) {
+  let library;
+  return () => {
+    library ??= loadLibrary(deps).catch((error) => {
+      library = undefined;
+      throw error;
+    });
+    return library;
+  };
+}
+var session;
+function sessionConnectorLibrary(url = FLOW_SDK_LIBRARY_URL) {
+  if (session?.url !== url) {
+    session = {
+      url,
+      load: createConnectorLibraryLoader({
+        url,
+        fetch: (target) => fetch(target),
+        openCache: async () => caches.open("flow-sdk-library")
+      })
+    };
+  }
+  return session.load();
+}
+function libraryMount({
+  archive
+}) {
+  return {
+    bytes: archive,
+    mountPath: MOUNT_PATH,
+    readTextSlot: READ_TEXT_SLOT
+  };
+}
+async function loadLibrary({
+  url,
+  fetch: fetch2,
+  openCache
+}) {
+  const sha256 = expectedChecksum(await (await fetchOk(fetch2, `${url}.sha256`)).text(), url);
+  const key = new Request(`${url}?sha256=${sha256}`);
+  const cache = await openCache().catch(() => {
+    return;
+  });
+  const cached = await cache?.match(key);
+  if (cached)
+    return { sha256, archive: await cached.blob() };
+  const archive = await (await fetchOk(fetch2, url)).blob();
+  const actual = hex(await crypto.subtle.digest("SHA-256", await archive.arrayBuffer()));
+  if (actual !== sha256) {
+    throw new ConnectorLibraryError(`${url} does not match its checksum: expected ${sha256}, received ${actual}`, "server_error");
+  }
+  if (cache) {
+    await cache.put(key, new Response(archive));
+    for (const stale of await cache.keys()) {
+      if (stale.url !== key.url)
+        await cache.delete(stale);
+    }
+  }
+  return { sha256, archive };
+}
+async function fetchOk(fetch2, url) {
+  const response = await fetch2(url).catch((error) => {
+    throw new ConnectorLibraryError(`downloading ${url} failed: ${error instanceof Error ? error.message : String(error)}`, "network_error");
+  });
+  if (!response.ok) {
+    throw new ConnectorLibraryError(`HTTP ${response.status} downloading ${url}`, "network_error");
+  }
+  return response;
+}
+function expectedChecksum(body, url) {
+  const hash = body.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+  if (!/^[a-f0-9]{64}$/.test(hash)) {
+    throw new ConnectorLibraryError(`${url}.sha256 is not a sha256 checksum`, "server_error");
+  }
+  return hash;
+}
+function hex(digest) {
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export {
+  LIBRARY_JSON,
+  libraryMount,
+  sessionConnectorLibrary
+};
+
+//# debugId=714515F8E06CF78B64756E2164756E21