@uipath/maestro-builder-sdk 6.56.0 → 6.57.0

package/dist/api-index.md

@@ -37,7 +37,7 @@ could hand you spans for a version you do not have.
 
 ## `@uipath/maestro-builder-sdk`
 
-232 symbol(s). Import from `@uipath/maestro-builder-sdk`.
+236 symbol(s). Import from `@uipath/maestro-builder-sdk`.
 
 | Symbol | Kind | Declaration | Area | Summary |
 | --- | --- | --- | --- | --- |
@@ -229,10 +229,14 @@ could hand you spans for a version you do not have.
 | `ScheduledInputs` | interface | `dist/flow-sdk.d.ts:151-163` | Option shapes | 1 field(s) |
 | `ScheduleEvery` | type | `dist/flow-sdk.d.ts:139-150` | Supporting types | How often a scheduled flow runs, as an ISO-8601 repeating interval: `R/` followed by a duration. |
 | `SchedulePreset` | type | `dist/flow-sdk.d.ts:138` | Supporting types |  |
-| `script` | function | `dist/nodes/script/flow/factories.d.ts:7-14` | Actions | Declare an inline script action. |
+| `script` | function | `dist/nodes/script/flow/factories.d.ts:8-36` | Actions | Declare an inline script action, as a TypeScript function the compiler checks. |
+| `script` | function | `dist/nodes/script/flow/factories.d.ts:37-47` | Actions | Declare an inline script action, as a TypeScript function, with no declared return: the body's type is inferred as it is… |
+| `script` | function | `dist/nodes/script/flow/factories.d.ts:48-55` | Actions | Declare an inline script action. |
 | `ScriptInputs` | interface | `dist/nodes/script/flow/spec.d.ts:7-44` | Option shapes | 2 field(s) |
 | `ScriptReturns` | type | `dist/core/script-return.d.ts:42-48` | Supporting types | What an author may write for `script({ returns })`: the type outright, or — for an object return — the FIELDS, which is… |
 | `ScriptReturnType` | type | `dist/core/script-return.d.ts:31-41` | Supporting types | The vocabulary a script's output can be declared as. |
+| `ScriptValue` | type | `dist/nodes/script/flow/spec.d.ts:65-75` | Supporting types | What a script function must return for a given `returns`: the type a name stands for, or, for a field map, an object… |
+| `ScriptValueOf` | type | `dist/nodes/script/flow/spec.d.ts:63-64` | Supporting types | The TypeScript type one of ScriptReturnType's names stands for. |
 | `sendMessage` | function | `dist/nodes/conversation/flow/factories.d.ts:8-26` | Actions | Post an assistant message into a live conversation (`uipath.conversational.send-message`). |
 | `SendMessageInputs` | interface | `dist/nodes/conversation/flow/spec.d.ts:8-27` | Option shapes | 4 field(s) |
 | `ShownField` | interface | `dist/core/actions.d.ts:205-220` | Supporting types | A value the reviewer READS: shown on the form, filled in from the flow. |

package/dist/api-members.md

@@ -976,7 +976,7 @@ not find it either.
 | `schemaVersion` | method | `FlowBuilder` | `dist/flow-sdk.d.ts:1581-1620` |
 | `scope` | property | `EscalationRecipient` | `dist/case/case-sdk.d.ts:129` |
 | `scopes` | property | `GuardrailSelector` | `dist/core/actions.d.ts:290` |
-| `script` | property | `FlowActionSpecs` | `dist/nodes/script/flow/spec.d.ts:47-50` |
+| `script` | property | `FlowActionSpecs` | `dist/nodes/script/flow/spec.d.ts:78-81` |
 | `script` | property | `ScriptTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:880-896` |
 | `scriptFormat` | property | `ScriptTaskOpts` | `dist/bpmn/bpmn-sdk.d.ts:897-898` |
 | `scriptTask` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2380-2388` |

package/dist/cli/commands/flow.js

@@ -93,10 +93,12 @@ export function registerFlowCommands(program) {
         .option('--strict', 'fail on unsupported constructs')
         .option('--no-pipeline', 'do not emit a brownfield pipeline helper')
         .option('--package <name...>', 'trust and load this node-type package (repeatable); otherwise package.json "maestroBuilderSdk".nodePackages decides')
+        .option('--scripts <form>', 'print script steps as "function" (the default) or "string"')
         .action(async (input, options) => {
         const argv = [input];
         addValue(argv, '-o', options.output);
         addValue(argv, '--import', options.import);
+        addValue(argv, '--scripts', options.scripts);
         if (options.strict)
             argv.push('--strict');
         if (options.pipeline === false)

package/dist/core/script-function.d.ts

@@ -0,0 +1,126 @@
+/**
+ * core/script-function — a TypeScript function lowered to a script body.
+ *
+ * A script body is a string the editor and tsc never see. Authoring it as a
+ * function lets the compiler check it like the rest of the module, and this file
+ * turns that function back into the body a script node carries
+ * (docs/SCRIPT_FUNCTION_DESIGN.md).
+ *
+ * The body is kept EXACTLY as `Function.prototype.toString()` returned it: the
+ * artifact goes to a designer, and the author expects to see the script they
+ * wrote. Only two edits are made, both because the runtime requires them:
+ *
+ *   1. the parameter is renamed to the runtime's own scope global (`$vars` in
+ *      Flow). The parameter is an authoring-time name for that global; the SDK
+ *      never calls the function or passes it anything.
+ *   2. esbuild's `keepNames` wrappers (`__name(fn, "fn")`) are removed. A loader
+ *      such as tsx adds them, and the script runtime has no `__name`.
+ *
+ * Everything else that would make the lowered body behave differently from the
+ * function is refused rather than rewritten: a name the runtime does not
+ * provide, a `$vars` binding that would capture the rename, a destructured
+ * parameter whose step reads `renameRefs` could not see, a reference to the
+ * function's own name, which only the body loses.
+ *
+ * Names are resolved with the checker of a one-file program over the function's
+ * source, not by text: `a.vars`, `{ vars: 1 }` and an inner `(vars) => …` are
+ * not references to the parameter, and only a checker knows that.
+ */
+import type * as TS from 'typescript';
+/** How a runtime receives a lowered script: its scope global, and every other name it provides. */
+export interface ScriptRuntime {
+    /** The identifier the runtime binds the variable scope to (`$vars` in Flow). */
+    scopeGlobal: string;
+    /** Every other global name the runtime provides: the language built-ins it has, `console`. */
+    globals: ReadonlySet<string>;
+    /** How errors name the runtime: `the Flow script runtime`. */
+    name: string;
+}
+/** A function, or its source text, as `Function.prototype.toString()` returns it. */
+export type ScriptFunctionSource = ((...args: never[]) => unknown) | string;
+/**
+ * The body a script node carries for `fn`, or a thrown error naming every
+ * reason it cannot be one.
+ *
+ * @param fn - The function, or its source text (what `fn.toString()` returns).
+ * @param runtime - The runtime the body will run in.
+ * @param label - How errors name the call, e.g. `script(parseMessage)`.
+ */
+export declare function lowerScriptFunction(fn: ScriptFunctionSource, runtime: ScriptRuntime, label?: string): string;
+/**
+ * The source of every function {@link lowerScriptFunction} has lowered in this
+ * process, in order, one entry per call.
+ *
+ * The CLIs that load a `.flow.ts` take the entries added while it imported,
+ * twice over: to decide whether the module-scope pass
+ * (`script-function-scope.ts`) has anything to look at, so a flow with no
+ * function scripts pays nothing for it; and to fail closed, by matching each
+ * lowered text to a declaration that pass followed, so a function it could not
+ * see is refused. Taken per load because one process may load two sources
+ * (`merge --baseline-from`).
+ */
+export declare function scriptFunctionLowerings(): readonly string[];
+/** Options for {@link tryLowerScriptFunction}. */
+export interface LowerOptions {
+    /**
+     * Refuse any use of the parameter other than a dotted read (`vars.start…`):
+     * an alias (`const v = vars`), a computed read (`vars['start']`), an optional
+     * read (`vars?.start`), or passing it on (`pick(vars)`, `{ vars }`) each hides
+     * the step it reads from `renameRefs` and the reference check, which see only
+     * `$vars.<name>`. Authoring (`script(fn)`) sets it; decompile's gate does not,
+     * because there the text is the node's own either way.
+     */
+    scopeReadsOnly?: boolean;
+}
+/** What lowering a function's source produced: its body, or every problem with it. */
+export type LoweredScript = {
+    ok: true;
+    code: string;
+}
+/**
+ * `free` is the names the runtime would not have, also described in `problems`;
+ * `syntax` is set when the source did not parse as one function at all.
+ */
+ | {
+    ok: false;
+    problems: string[];
+    free: string[];
+    syntax?: true;
+};
+/**
+ * {@link lowerScriptFunction} without the throw, for a caller that falls back
+ * when the source cannot be lowered (decompile's function-form gate).
+ */
+export declare function tryLowerScriptFunction(source: string, runtime: ScriptRuntime, options?: LowerOptions): LoweredScript;
+/**
+ * The first syntax error in a script BODY (the text a script node carries), as
+ * `line N: message`, or undefined when it parses. Lines are the body's own.
+ */
+export declare function scriptBodySyntaxError(code: string): string | undefined;
+/**
+ * The JavaScript engine's early error for a body run as
+ * `function (<scopeGlobal>) { "use strict"; <code> }`, or undefined when it has
+ * none.
+ *
+ * TypeScript's parser does not report early errors (a duplicate `let`, a
+ * `const $vars` that clashes with the parameter, an octal literal in strict
+ * code), and the printed function lives in an ES module, which is strict. A body
+ * with one would make the whole module unloadable, so decompile asks the engine.
+ * The body is compiled, never called. A host without the `Function`
+ * constructor (a strict content-security policy) cannot answer, which is
+ * reported as an error too, so the caller keeps the string form.
+ */
+export declare function scriptBodyEarlyError(code: string, runtime: ScriptRuntime): string | undefined;
+/**
+ * The first piece of TypeScript-only syntax in a body, described, or undefined.
+ *
+ * A string body is JavaScript, but the printed function is read by a TypeScript
+ * loader, which erases type syntax before the runtime ever sees it: a body with
+ * `const n: number = 1` would come back from compile as `const n         = 1`,
+ * and `f<T>(x)`, which JavaScript reads as two comparisons, would come back as a
+ * call. Either silently changes the stored script, so such a body keeps the
+ * string form.
+ */
+export declare function scriptBodyTypeScriptSyntax(code: string): string | undefined;
+/** Whether `id` is read as a value, not a property name, label, or type. */
+export declare function isReference(ts: typeof TS, id: TS.Identifier): boolean;