@uipath/apollo-wind 2.60.1 → 2.61.0

package/dist/components/forms/field-actions.cjs

@@ -0,0 +1,181 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createClearAction: ()=>createClearAction,
+    resolveVariables: ()=>resolveVariables,
+    createInsertVariableAction: ()=>createInsertVariableAction,
+    resolveFieldActions: ()=>resolveFieldActions,
+    DEFAULT_FIELD_ACTION_REGISTRY: ()=>DEFAULT_FIELD_ACTION_REGISTRY,
+    buildFieldActionRegistry: ()=>buildFieldActionRegistry,
+    createAiAssistAction: ()=>createAiAssistAction
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_lucide_react_namespaceObject = require("lucide-react");
+const ai_assist_action_cjs_namespaceObject = require("../ui/field-actions/ai-assist-action.cjs");
+const insert_variable_action_cjs_namespaceObject = require("../ui/field-actions/insert-variable-action.cjs");
+function resolveVariables(source, field) {
+    if (!source) return [];
+    return 'function' == typeof source ? source({
+        field
+    }) : source;
+}
+function offers(ctx, mode) {
+    return !!ctx.setModeValue && !!ctx.field.valueModes?.modes.includes(mode);
+}
+const REPLACED_WITHOUT_ASKING = new Set([
+    'number',
+    'boolean',
+    'switch',
+    'checkbox'
+]);
+function insertTarget(ctx, formatReference, text) {
+    if (ctx.disabled) return;
+    if (ctx.insertable) {
+        const insertText = ctx.control?.insertText;
+        if (!insertText) return;
+        const mode = ctx.mode?.mode ?? 'literal';
+        return (reference)=>insertText(formatReference?.(reference, {
+                field: ctx.field,
+                mode
+            }) ?? reference);
+    }
+    const confirm = ctx.mode?.mode === 'literal' && REPLACED_WITHOUT_ASKING.has(ctx.field.type) ? void 0 : {
+        title: text.replaceTitle,
+        description: text.replaceDescription,
+        confirmLabel: text.replaceConfirm
+    };
+    for (const mode of [
+        'expression',
+        'variable'
+    ])if (offers(ctx, mode)) return (reference)=>ctx.setModeValue?.(mode, reference, {
+            confirm
+        });
+}
+function createInsertVariableAction({ variables, formatReference, strings, id = 'insert-variable' }) {
+    return {
+        id,
+        render: (ctx)=>{
+            if (ctx.mode?.mode === 'variable') return null;
+            const text = {
+                ...ctx.strings.insertVariable,
+                ...strings
+            };
+            const insert = insertTarget(ctx, formatReference, text);
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(insert_variable_action_cjs_namespaceObject.InsertVariableAction, {
+                variables: Array.isArray(variables) ? variables : ()=>variables ? resolveVariables(variables, ctx.field) : ctx.variables(),
+                onInsert: insert && ((reference)=>insertTarget(ctx, formatReference, text)?.(reference)),
+                disabled: ctx.disabled,
+                strings: text
+            });
+        }
+    };
+}
+function createAiAssistAction({ generate, hint, placeholder, strings, id = 'ai-assist' }) {
+    return {
+        id,
+        render: (ctx)=>{
+            const promptPlaceholder = 'function' == typeof placeholder ? placeholder(ctx) : placeholder;
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ai_assist_action_cjs_namespaceObject.AiAssistAction, {
+                onGenerate: async (prompt)=>{
+                    const result = await generate({
+                        prompt
+                    }, ctx);
+                    if (!result || ctx.disabled) return;
+                    const mode = result.mode ?? ctx.mode?.mode;
+                    if (ctx.setModeValue && mode) ctx.setModeValue(mode, result.value);
+                    else ctx.setValue(result.value);
+                },
+                hint: 'function' == typeof hint ? hint(ctx) : hint,
+                disabled: ctx.disabled,
+                strings: {
+                    ...ctx.strings.aiAssist,
+                    ...void 0 !== promptPlaceholder && {
+                        promptPlaceholder
+                    },
+                    ...strings
+                }
+            });
+        }
+    };
+}
+function createClearAction({ strings, id = 'clear' } = {}) {
+    return {
+        id,
+        label: (ctx)=>strings?.label ?? ctx.strings.clear.label,
+        icon: external_lucide_react_namespaceObject.Eraser,
+        destructive: true,
+        disabled: (ctx)=>ctx.disabled || ctx.empty,
+        onSelect: (ctx)=>ctx.clear()
+    };
+}
+function buildFieldActionRegistry(plugins) {
+    const registry = {
+        header: {},
+        menu: {
+            clear: createClearAction()
+        }
+    };
+    for (const { fieldActions } of plugins){
+        Object.assign(registry.header, fieldActions?.header);
+        Object.assign(registry.menu, fieldActions?.menu);
+    }
+    return registry;
+}
+const DEFAULT_FIELD_ACTION_REGISTRY = (()=>{
+    const { header, menu } = buildFieldActionRegistry([]);
+    return Object.freeze({
+        header: Object.freeze(header),
+        menu: Object.freeze(menu)
+    });
+})();
+function resolveFieldActions(field, registry) {
+    const pick = (ids, actions)=>(ids ?? []).flatMap((id)=>actions[id] ? [
+                actions[id]
+            ] : []);
+    return {
+        header: pick(field.headerActions, registry.header),
+        menu: pick(field.menuActions, registry.menu)
+    };
+}
+exports.DEFAULT_FIELD_ACTION_REGISTRY = __webpack_exports__.DEFAULT_FIELD_ACTION_REGISTRY;
+exports.buildFieldActionRegistry = __webpack_exports__.buildFieldActionRegistry;
+exports.createAiAssistAction = __webpack_exports__.createAiAssistAction;
+exports.createClearAction = __webpack_exports__.createClearAction;
+exports.createInsertVariableAction = __webpack_exports__.createInsertVariableAction;
+exports.resolveFieldActions = __webpack_exports__.resolveFieldActions;
+exports.resolveVariables = __webpack_exports__.resolveVariables;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_FIELD_ACTION_REGISTRY",
+    "buildFieldActionRegistry",
+    "createAiAssistAction",
+    "createClearAction",
+    "createInsertVariableAction",
+    "resolveFieldActions",
+    "resolveVariables"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/forms/field-actions.d.ts

@@ -0,0 +1,131 @@
+import { type LucideIcon } from 'lucide-react';
+import type * as React from 'react';
+import type { FieldValues, UseFormReturn } from 'react-hook-form';
+import { type AiAssistActionStrings } from '../ui/field-actions/ai-assist-action';
+import { type InsertVariableActionStrings } from '../ui/field-actions/insert-variable-action';
+import type { VariablePickerItem } from '../ui/variable-picker';
+import type { FieldMetadata, FormPlugin, FormVariables, ValueModeId } from './form-schema';
+import type { ClearActionStrings, MetadataFormStrings } from './form-strings';
+import type { DecodedValue, ValueModeControlHandle } from './value-modes';
+/** What an action sees of its field. Read when the action runs, so it is always current. */
+export interface FieldActionContext {
+    field: FieldMetadata;
+    name: string;
+    /** The stored value. */
+    value: unknown;
+    /** Writes the stored value. Never `undefined`, which the form reads as unset: clear with `null`. */
+    setValue(value: unknown): void;
+    /** Empties the value, keeping its mode; a field without value modes is set to `null`. */
+    clear(): void;
+    /** Whether the value is empty, decoded first on a field with `valueModes`. */
+    empty: boolean;
+    disabled: boolean;
+    /** The active value control, for focus and caret insertion. */
+    control: ValueModeControlHandle | null;
+    /** Whether the active control takes text at its caret. */
+    insertable: boolean;
+    /** The form's variables for this field, resolved when called; never call it during render. */
+    variables(): ValueModeVariable[];
+    form: UseFormReturn<FieldValues>;
+    /** The form's strings, every plugin's over the English defaults. */
+    strings: MetadataFormStrings;
+    /** The decoded value. Only on a field with `valueModes`. */
+    mode?: DecodedValue;
+    /**
+     * Writes `inner` in `mode`. With `confirm`, a non-empty value is replaced only once the user
+     * confirms, in the lossy-switch dialog worded as `confirm` gives. Only on a field with
+     * `valueModes`.
+     */
+    setModeValue?(mode: ValueModeId, inner: unknown, options?: {
+        confirm?: FieldActionConfirm;
+    }): void;
+}
+/** The wording of a confirmation; each part defaults to the lossy-switch dialog's. */
+export interface FieldActionConfirm {
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+}
+/** An action behind the field's label. */
+export interface FieldHeaderAction {
+    id: string;
+    render(ctx: FieldActionContext): React.ReactNode;
+}
+/** A row of the field's trailing menu, below its modes. */
+export interface FieldMenuAction {
+    id: string;
+    label: string | ((ctx: FieldActionContext) => string);
+    icon?: LucideIcon;
+    destructive?: boolean;
+    disabled?(ctx: FieldActionContext): boolean;
+    onSelect(ctx: FieldActionContext): void;
+}
+/** A variable Insert variable offers, rendered as supplied. */
+export type ValueModeVariable = VariablePickerItem;
+/** `source` for `field`: a function is called now, so only call this when a picker opens. */
+export declare function resolveVariables(source: FormVariables | undefined, field: FieldMetadata): ValueModeVariable[];
+/**
+ * Generates a value from a prompt. Resolving with a value writes it, in `mode` or else the mode
+ * the field is in when it resolves; resolving with nothing writes nothing.
+ */
+export type FieldActionGenerate = (request: {
+    prompt: string;
+}, ctx: FieldActionContext) => Promise<{
+    mode?: ValueModeId;
+    value: unknown;
+} | undefined | void>;
+export interface FieldActionsPluginConfig {
+    /** Header actions by id, in the order fields list them. */
+    header?: Record<string, FieldHeaderAction>;
+    /** Menu actions by id. `clear` is registered unless a plugin replaces it. */
+    menu?: Record<string, FieldMenuAction>;
+}
+/** Every plugin's `fieldActions` over the default `clear`, later plugins winning by id. */
+export interface FieldActionRegistry {
+    header: Record<string, FieldHeaderAction>;
+    menu: Record<string, FieldMenuAction>;
+}
+export interface InsertVariableActionOptions {
+    /** Defaults to the form's `FormPlugin.variables`. */
+    variables?: FormVariables;
+    /**
+     * How a picked reference is written at the caret, such as `{{ ref }}` inside fixed-value text.
+     * A field that switches to `expression` or `variable` to take the reference gets it as picked.
+     */
+    formatReference?: (reference: string, ctx: {
+        field: FieldMetadata;
+        mode: ValueModeId;
+    }) => string;
+    strings?: Partial<InsertVariableActionStrings>;
+    /** Defaults to `insert-variable`. */
+    id?: string;
+}
+/** Insert variable: a variable picker behind the label that writes the picked reference. */
+export declare function createInsertVariableAction({ variables, formatReference, strings, id, }: InsertVariableActionOptions): FieldHeaderAction;
+export interface AiAssistActionOptions {
+    generate: FieldActionGenerate;
+    /** Guidance under the prompt, such as the value type expected. */
+    hint?: React.ReactNode | ((ctx: FieldActionContext) => React.ReactNode);
+    /** The prompt's placeholder, such as an example request for this field. */
+    placeholder?: string | ((ctx: FieldActionContext) => string);
+    strings?: Partial<AiAssistActionStrings>;
+    /** Defaults to `ai-assist`. */
+    id?: string;
+}
+/** AI assist: a prompt behind the label whose generated value is written to the field. */
+export declare function createAiAssistAction({ generate, hint, placeholder, strings, id, }: AiAssistActionOptions): FieldHeaderAction;
+export interface ClearActionOptions {
+    strings?: Partial<ClearActionStrings>;
+    /** Defaults to `clear`. */
+    id?: string;
+}
+/** Clear value: a menu row that empties the value, keeping its mode. */
+export declare function createClearAction({ strings, id, }?: ClearActionOptions): FieldMenuAction;
+export declare function buildFieldActionRegistry(plugins: readonly FormPlugin[]): FieldActionRegistry;
+/** The registry of a form whose plugins add no actions: just Clear. Frozen, as it is shared. */
+export declare const DEFAULT_FIELD_ACTION_REGISTRY: Readonly<FieldActionRegistry>;
+/** A field's actions in its order. Unregistered ids are left out. */
+export declare function resolveFieldActions(field: FieldMetadata, registry: FieldActionRegistry): {
+    header: FieldHeaderAction[];
+    menu: FieldMenuAction[];
+};

package/dist/components/forms/field-actions.js

@@ -0,0 +1,129 @@
+import { jsx } from "react/jsx-runtime";
+import { Eraser } from "lucide-react";
+import { AiAssistAction } from "../ui/field-actions/ai-assist-action.js";
+import { InsertVariableAction } from "../ui/field-actions/insert-variable-action.js";
+function resolveVariables(source, field) {
+    if (!source) return [];
+    return 'function' == typeof source ? source({
+        field
+    }) : source;
+}
+function offers(ctx, mode) {
+    return !!ctx.setModeValue && !!ctx.field.valueModes?.modes.includes(mode);
+}
+const REPLACED_WITHOUT_ASKING = new Set([
+    'number',
+    'boolean',
+    'switch',
+    'checkbox'
+]);
+function insertTarget(ctx, formatReference, text) {
+    if (ctx.disabled) return;
+    if (ctx.insertable) {
+        const insertText = ctx.control?.insertText;
+        if (!insertText) return;
+        const mode = ctx.mode?.mode ?? 'literal';
+        return (reference)=>insertText(formatReference?.(reference, {
+                field: ctx.field,
+                mode
+            }) ?? reference);
+    }
+    const confirm = ctx.mode?.mode === 'literal' && REPLACED_WITHOUT_ASKING.has(ctx.field.type) ? void 0 : {
+        title: text.replaceTitle,
+        description: text.replaceDescription,
+        confirmLabel: text.replaceConfirm
+    };
+    for (const mode of [
+        'expression',
+        'variable'
+    ])if (offers(ctx, mode)) return (reference)=>ctx.setModeValue?.(mode, reference, {
+            confirm
+        });
+}
+function createInsertVariableAction({ variables, formatReference, strings, id = 'insert-variable' }) {
+    return {
+        id,
+        render: (ctx)=>{
+            if (ctx.mode?.mode === 'variable') return null;
+            const text = {
+                ...ctx.strings.insertVariable,
+                ...strings
+            };
+            const insert = insertTarget(ctx, formatReference, text);
+            return /*#__PURE__*/ jsx(InsertVariableAction, {
+                variables: Array.isArray(variables) ? variables : ()=>variables ? resolveVariables(variables, ctx.field) : ctx.variables(),
+                onInsert: insert && ((reference)=>insertTarget(ctx, formatReference, text)?.(reference)),
+                disabled: ctx.disabled,
+                strings: text
+            });
+        }
+    };
+}
+function createAiAssistAction({ generate, hint, placeholder, strings, id = 'ai-assist' }) {
+    return {
+        id,
+        render: (ctx)=>{
+            const promptPlaceholder = 'function' == typeof placeholder ? placeholder(ctx) : placeholder;
+            return /*#__PURE__*/ jsx(AiAssistAction, {
+                onGenerate: async (prompt)=>{
+                    const result = await generate({
+                        prompt
+                    }, ctx);
+                    if (!result || ctx.disabled) return;
+                    const mode = result.mode ?? ctx.mode?.mode;
+                    if (ctx.setModeValue && mode) ctx.setModeValue(mode, result.value);
+                    else ctx.setValue(result.value);
+                },
+                hint: 'function' == typeof hint ? hint(ctx) : hint,
+                disabled: ctx.disabled,
+                strings: {
+                    ...ctx.strings.aiAssist,
+                    ...void 0 !== promptPlaceholder && {
+                        promptPlaceholder
+                    },
+                    ...strings
+                }
+            });
+        }
+    };
+}
+function createClearAction({ strings, id = 'clear' } = {}) {
+    return {
+        id,
+        label: (ctx)=>strings?.label ?? ctx.strings.clear.label,
+        icon: Eraser,
+        destructive: true,
+        disabled: (ctx)=>ctx.disabled || ctx.empty,
+        onSelect: (ctx)=>ctx.clear()
+    };
+}
+function buildFieldActionRegistry(plugins) {
+    const registry = {
+        header: {},
+        menu: {
+            clear: createClearAction()
+        }
+    };
+    for (const { fieldActions } of plugins){
+        Object.assign(registry.header, fieldActions?.header);
+        Object.assign(registry.menu, fieldActions?.menu);
+    }
+    return registry;
+}
+const DEFAULT_FIELD_ACTION_REGISTRY = (()=>{
+    const { header, menu } = buildFieldActionRegistry([]);
+    return Object.freeze({
+        header: Object.freeze(header),
+        menu: Object.freeze(menu)
+    });
+})();
+function resolveFieldActions(field, registry) {
+    const pick = (ids, actions)=>(ids ?? []).flatMap((id)=>actions[id] ? [
+                actions[id]
+            ] : []);
+    return {
+        header: pick(field.headerActions, registry.header),
+        menu: pick(field.menuActions, registry.menu)
+    };
+}
+export { DEFAULT_FIELD_ACTION_REGISTRY, buildFieldActionRegistry, createAiAssistAction, createClearAction, createInsertVariableAction, resolveFieldActions, resolveVariables };