fig-tree-evaluator 3.0.0-preview.10 → 3.0.0-preview.12

package/build/catalog/index.d.ts

@@ -0,0 +1,502 @@
+declare const ErrorCodes: {
+    readonly typeCheck: "type-check";
+    readonly operatorFailure: "operator-failure";
+    readonly requestTimeout: "request-timeout";
+    readonly httpStatus: "http-status";
+    readonly invalidResponse: "invalid-response";
+    readonly graphQLErrors: "graphql-errors";
+    readonly sqlError: "sql-error";
+    readonly requestFailure: "request-failure";
+    readonly nonFiniteResult: "non-finite-result";
+    readonly escapedHandle: "escaped-handle";
+    readonly emptyAggregate: "empty-aggregate";
+    readonly missingDataPath: "missing-data-path";
+    readonly missingRequired: "missing-required";
+    readonly timeout: "timeout";
+    readonly aborted: "aborted";
+    readonly malformedNode: "malformed-node";
+    readonly unknownOperator: "unknown-operator";
+    readonly unknownFragment: "unknown-fragment";
+    readonly unknownNodeKey: "unknown-node-key";
+    readonly unrecognizedIdentifier: "unrecognized-identifier";
+    readonly positionalArity: "positional-arity";
+    readonly invalidVars: "invalid-vars";
+    readonly invalidReference: "invalid-reference";
+    readonly invalidAs: "invalid-as";
+    readonly unresolvedVar: "unresolved-var";
+    readonly unresolvedParam: "unresolved-param";
+    readonly unresolvedBinding: "unresolved-binding";
+    readonly bareVars: "bare-vars";
+    readonly varCycle: "var-cycle";
+    readonly depthCeiling: "depth-ceiling";
+    readonly maxDepthExceeded: "max-depth";
+    readonly maxNodesExceeded: "max-nodes";
+    readonly returnsMismatch: "returns-mismatch";
+    readonly operatorValidate: "operator-validate";
+    readonly uselessModifier: "useless-modifier";
+    readonly unreferencedVar: "unreferenced-var";
+    readonly shadowedVar: "shadowed-var";
+    readonly deadBinding: "dead-binding";
+    readonly fallbackMismatch: "fallback-mismatch";
+    readonly unboundToken: "unbound-token";
+    readonly unusedSubstitution: "unused-substitution";
+    readonly inertReferenceToken: "inert-reference-token";
+    readonly invalidDefinition: "invalid-definition";
+    readonly invalidName: "invalid-name";
+    readonly reservedName: "reserved-name";
+    readonly invalidNullPolicy: "invalid-null-policy";
+    readonly duplicateOperator: "duplicate-operator";
+    readonly fragmentCycle: "fragment-cycle";
+    readonly invalidOptions: "invalid-options";
+};
+type KnownErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+type FigTreeErrorCode = KnownErrorCode | (string & {});
+type KnownFallbackErrorCode = (typeof ErrorCodes)['typeCheck' | 'operatorFailure' | 'requestTimeout' | 'httpStatus' | 'invalidResponse' | 'graphQLErrors' | 'sqlError' | 'requestFailure' | 'nonFiniteResult' | 'escapedHandle' | 'emptyAggregate' | 'missingDataPath' | 'missingRequired' | 'timeout'];
+type FallbackErrorCode = KnownFallbackErrorCode | (string & {});
+
+interface CacheStore {
+    get(key: string): unknown | Promise<unknown>;
+    set(key: string, value: unknown): void;
+    delete(key: string): void;
+    clear(): void;
+}
+
+type BasicType = 'any' | 'string' | 'number' | 'boolean' | 'array' | 'object' | 'null' | 'integer';
+type LiteralType = {
+    literal: readonly (string | number | boolean)[];
+};
+type ExpectedType = BasicType | LiteralType | readonly BasicType[];
+interface Constraints {
+    length?: number;
+    homogeneous?: readonly BasicType[];
+    elementShape?: Record<string, TypeDeclaration>;
+}
+interface TypeDeclaration {
+    type?: ExpectedType;
+    required?: boolean;
+    constraints?: Constraints;
+}
+type TypeCheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    expected: string;
+    actual: string;
+};
+
+declare const WILDCARD: unique symbol;
+type Wildcard = typeof WILDCARD;
+type PathSegment = string | number | Wildcard;
+interface ResolveResult {
+    found: boolean;
+    value: unknown;
+}
+
+interface Dependencies {
+    data: {
+        paths: string[];
+        dynamic: boolean;
+    };
+    operators: string[];
+    fragments: string[];
+}
+interface ParameterInfo extends ValidatedParameter {
+    hostDefault?: unknown;
+}
+interface OperatorInfo extends Omit<ValidatedOperatorDefinition, typeof VALIDATED_OPERATOR | 'evaluate' | 'validate' | 'deliversLazily' | 'resolution' | 'fingerprint' | 'parameters'> {
+    parameters: Record<string, ParameterInfo>;
+    hasValidate: boolean;
+    hostNoCache?: true;
+    hostFallback?: unknown;
+}
+interface FragmentInfo {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    parameters: Record<string, FragmentParameter>;
+    returns: ExpectedType;
+    warnings: Issue[];
+    dependencies: Dependencies;
+    caches: boolean;
+}
+
+declare class FigTree<InstanceOpts extends FigTreeOptions = NoOptions> {
+    private state;
+    private readonly results;
+    readonly version = "3.0.0-preview.12";
+    constructor(options?: InstanceOpts);
+    updateOptions(options?: OptionsUpdate): void;
+    clearCache(): void;
+    getOptions(): EvaluationOptions;
+    getOperators(): OperatorInfo[];
+    getFragments(): FragmentInfo[];
+    validate(expression: unknown, options?: CallOptions): ValidationResult;
+    getDependencies(expression: unknown): Dependencies;
+    isEvaluable(expression: unknown): boolean;
+    evaluate<CallOpts extends CallOptions = NoOptions>(expression: unknown, options?: OnlyCallOptions<CallOpts>): Promise<ResultShape<Merge<InstanceOpts, CallOpts>>>;
+    compile(expression: unknown): CompiledExpression<InstanceOpts>;
+}
+declare class CompiledExpression<InstanceOpts extends FigTreeOptions = NoOptions> {
+    #private;
+    private constructor();
+    get expression(): unknown;
+    get issues(): readonly Issue[];
+    get hasErrors(): boolean;
+    evaluate<CallOpts extends CallOptions = NoOptions>(options?: OnlyCallOptions<CallOpts>): Promise<ResultShape<Merge<InstanceOpts, CallOpts>>>;
+    getDependencies(): Dependencies;
+}
+
+interface OperatorAnalysis {
+    failures?: FailureRule[];
+    external?: true;
+    output?: DeclaredOutput;
+}
+interface FailureRule {
+    code: FallbackErrorCode;
+    parameter?: string;
+    when?: Record<string, FailureTest>;
+    options?: Record<string, unknown>;
+    may?: true;
+    overflow?: true;
+}
+type FailureTest = string | number | boolean | null | {
+    type: ExpectedType;
+} | {
+    below: number;
+} | {
+    empty: true;
+} | {
+    supplied: boolean;
+} | {
+    invalid: true;
+} | {
+    some: FailureTest;
+} | {
+    not: FailureTest;
+};
+type DeclaredOutput = ExpectedType | {
+    type: 'number' | 'integer';
+    min?: number;
+    max?: number;
+} | {
+    type: 'string' | 'array';
+    minLength?: number;
+} | {
+    param: string;
+} | {
+    elementOf: string;
+} | {
+    kindOf: string;
+} | {
+    arrayOf: DeclaredOutput;
+    minLength?: number;
+} | {
+    oneOf: DeclaredOutput[];
+} | {
+    typeNamedBy: string;
+} | {
+    byParam: string;
+    cases: Record<string, DeclaredOutput>;
+    otherwise?: DeclaredOutput;
+} | {
+    firstNonNull: string;
+} | {
+    sum: string;
+} | {
+    product: string;
+} | {
+    difference: [string, string];
+} | {
+    abs: string;
+} | {
+    min: string;
+} | {
+    max: string;
+};
+
+declare const validateHelpers: Readonly<{
+    parsePath: (path: string) => PathSegment[];
+    resolvePath: (source: unknown, path: string | PathSegment[]) => ResolveResult;
+    checkType: (value: unknown, expected: ExpectedType) => TypeCheckResult;
+    checkConstraints: (value: unknown, constraints: Constraints) => TypeCheckResult;
+    describeType: (value: unknown) => string;
+    renderText: (value: unknown) => string;
+    isTruthy: (value: unknown) => boolean;
+}>;
+type ValidateHelpers = typeof validateHelpers;
+
+type EvaluationMode = 'eager' | 'race' | 'lazy' | 'lazyElements' | 'lazyEntries' | 'perElement' | 'structural';
+declare const OPERATOR_CATEGORIES: readonly ["logic", "comparison", "math", "string", "array", "data", "io", "other"];
+type OperatorCategory = (typeof OPERATOR_CATEGORIES)[number];
+type NullPolicyValue = 'propagate' | 'value';
+interface CompiledNullPolicy {
+    selector: string;
+    table: {
+        value: string | number | boolean;
+        policy: NullPolicyValue;
+    }[];
+}
+type OperatorEvaluate = (params: Record<string, unknown>, context: OperatorContext) => unknown;
+interface ValidateFinding {
+    severity: Severity;
+    message: string;
+    parameter?: string;
+}
+type OperatorValidate = (literalParams: Record<string, unknown>, helpers: ValidateHelpers) => ValidateFinding[];
+declare const VALIDATED_OPERATOR: unique symbol;
+interface ValidatedParameter {
+    type: ExpectedType;
+    required: boolean;
+    default?: unknown;
+    metadata?: Record<string, unknown>;
+    evaluation: EvaluationMode;
+    truthiness: boolean;
+    nullPolicy: NullPolicyValue | CompiledNullPolicy;
+    elementNullPolicy?: NullPolicyValue;
+    constraints?: Constraints;
+    over?: string;
+    replacesNullAt?: string[];
+}
+interface ValidatedOperatorDefinition {
+    readonly [VALIDATED_OPERATOR]: true;
+    name: string;
+    alias?: string;
+    category: OperatorCategory;
+    metadata?: Record<string, unknown>;
+    parameters: Record<string, ValidatedParameter>;
+    positionalParams?: string[];
+    restParam: string | null;
+    resolution: ResolutionPlan;
+    deliversLazily: boolean;
+    timeoutParam: string | null;
+    cache: boolean;
+    fingerprint: string;
+    validate?: OperatorValidate;
+    analysis?: OperatorAnalysis;
+    evaluate: OperatorEvaluate;
+    returns: ExpectedType;
+}
+type DeclarationEntry = readonly [name: string, declared: ValidatedParameter];
+interface ResolutionPlan {
+    readonly entries: readonly DeclarationEntry[];
+    readonly whole: readonly DeclarationEntry[];
+    readonly perElement: readonly DeclarationEntry[];
+}
+
+type EvaluationOptions = Omit<FigTreeOptions, 'operators' | 'fragments'>;
+type CallOptions = Pick<FigTreeOptions, 'data' | 'signal' | 'timeout' | 'trace'>;
+type OnlyCallOptions<CallOpts> = CallOpts & {
+    [Key in Exclude<keyof CallOpts, keyof CallOptions>]: never;
+};
+interface FigTreeOptions {
+    data?: Record<string, unknown>;
+    fragments?: Record<string, FragmentDefinition>;
+    operators?: (ValidatedOperatorDefinition | ValidatedOperatorDefinition[])[];
+    operatorDefaults?: {
+        [operator: string]: {
+            noCache?: true;
+            fallback?: unknown;
+            [param: string]: unknown;
+        };
+    };
+    http?: {
+        baseEndpoint?: string;
+        headers?: Record<string, string>;
+    };
+    graphQL?: {
+        endpoint?: string;
+        headers?: Record<string, string>;
+    };
+    strictDataPaths?: boolean;
+    maxDepth?: number;
+    maxNodes?: number;
+    timeout?: number;
+    signal?: AbortSignal;
+    cache?: {
+        store?: CacheStore;
+        maxSize?: number;
+        maxTime?: number;
+    };
+    trace?: boolean;
+}
+type OptionsUpdate = {
+    [Key in keyof FigTreeOptions]?: (Key extends MergedBlock ? Removable<NonNullable<FigTreeOptions[Key]>> : FigTreeOptions[Key]) | null;
+};
+type MergedBlock = 'fragments' | 'operatorDefaults' | 'http' | 'graphQL' | 'cache';
+type Removable<Block> = {
+    [Key in keyof Block]?: Block[Key] | null;
+};
+interface EvaluationResult {
+    result: unknown;
+    trace: TraceNode;
+}
+type NoOptions = Record<never, never>;
+type Merge<Instance, Call> = Omit<Instance, keyof Call> & Call;
+type ResultShape<O> = O extends {
+    trace: true;
+} ? EvaluationResult : unknown;
+
+type TraceEvent = {
+    type: string;
+    [key: string]: unknown;
+};
+interface OperatorContext {
+    signal: AbortSignal;
+    options: Readonly<EvaluationOptions>;
+    cache: {
+        memo<T>(key: unknown, fn: () => Promise<T>): Promise<T>;
+    };
+    trace: {
+        note(event: TraceEvent): void;
+    };
+}
+
+type TraceStatus = 'value' | 'failed' | 'fallback' | 'cancelled' | 'skipped';
+type TraceKind = 'operator' | 'fragment' | 'reference' | 'literal' | 'skeleton';
+interface TraceNode {
+    path: (string | number)[];
+    source?: {
+        fragment: string;
+    };
+    kind: TraceKind;
+    operator?: string;
+    ref?: string;
+    var?: string;
+    status: TraceStatus;
+    value?: unknown;
+    error?: FigTreeError;
+    events?: TraceEvent[];
+    children?: TraceNode[];
+    elapsed?: number;
+    warnings?: Issue[];
+}
+
+interface FigTreeErrorInit {
+    code: FigTreeErrorCode;
+    message: string;
+    path: (string | number)[];
+    operator?: string;
+    fragment?: string;
+    fragmentPath?: (string | number)[];
+    errorData?: Record<string, unknown>;
+    related?: FigTreeError[];
+    cause?: unknown;
+    issues?: Issue[];
+    trace?: TraceNode;
+}
+declare class FigTreeError extends Error {
+    code: FigTreeErrorCode;
+    path: (string | number)[];
+    operator?: string;
+    fragment?: string;
+    fragmentPath?: (string | number)[];
+    errorData?: Record<string, unknown>;
+    related?: FigTreeError[];
+    cause?: unknown;
+    issues?: Issue[];
+    trace?: TraceNode;
+    constructor(init: FigTreeErrorInit);
+    prettyPrint(): string;
+}
+
+type Severity = 'error' | 'warning';
+interface Issue {
+    severity: Severity;
+    code: FigTreeErrorCode;
+    message: string;
+    path: (string | number)[];
+    operator?: string;
+    fragment?: string;
+    parameter?: string;
+    suggestion?: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    issues: Issue[];
+}
+
+interface FragmentParameterDeclaration extends TypeDeclaration {
+    default?: unknown;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FragmentDefinition {
+    expression: unknown;
+    parameters?: Record<string, FragmentParameterDeclaration>;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FragmentParameter {
+    type: ExpectedType;
+    required: boolean;
+    default?: unknown;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    constraints?: Constraints;
+}
+
+interface OperatorListing {
+    displayName?: string;
+    description?: string;
+    parameterDescriptions?: {
+        [parameter: string]: string;
+    };
+    docUrl?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    seeds?: {
+        [parameter: string]: unknown;
+    };
+}
+interface CategoryListing {
+    displayName: string;
+    order: number;
+    backgroundColor: string;
+    textColor: string;
+}
+type OperatorListingMap = {
+    [operator: string]: OperatorListing;
+};
+type CategoryListingMap = {
+    [category in OperatorCategory]: CategoryListing;
+};
+type TypeSeeds = {
+    [type in BasicType]: unknown;
+};
+interface CatalogCategory extends CategoryListing {
+    name: OperatorCategory;
+}
+interface CatalogParameter extends ParameterInfo {
+    description?: string;
+    seed: unknown;
+}
+interface CatalogOperator extends Omit<OperatorInfo, 'parameters'> {
+    displayName: string;
+    description?: string;
+    docUrl?: string;
+    backgroundColor: string;
+    textColor: string;
+    parameters: Record<string, CatalogParameter>;
+}
+interface CatalogFragmentParameter extends FragmentParameter {
+    seed: unknown;
+}
+interface CatalogFragment extends Omit<FragmentInfo, 'parameters'> {
+    displayName: string;
+    docUrl?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    parameters: Record<string, CatalogFragmentParameter>;
+}
+interface Catalog {
+    categories: CatalogCategory[];
+    operators: CatalogOperator[];
+    fragments: CatalogFragment[];
+}
+
+declare const categoryListings: CategoryListingMap;
+declare const typeSeeds: TypeSeeds;
+declare const operatorListings: OperatorListingMap;
+declare const getCatalog: (fig: Pick<FigTree, "getOperators" | "getFragments">, ...listings: OperatorListingMap[]) => Catalog;
+
+export { categoryListings, getCatalog, operatorListings, typeSeeds };

package/build/catalog/index.js

@@ -0,0 +1 @@
+const e={logic:{displayName:"Logic & control",order:0,backgroundColor:"#632fbc",textColor:"#ffffff"},comparison:{displayName:"Comparison",order:1,backgroundColor:"#247f7c",textColor:"#ffffff"},math:{displayName:"Arithmetic & math",order:2,backgroundColor:"#2b8237",textColor:"#ffffff"},string:{displayName:"Strings",order:3,backgroundColor:"#a1660c",textColor:"#ffffff"},array:{displayName:"Arrays & iteration",order:4,backgroundColor:"#236ac7",textColor:"#ffffff"},data:{displayName:"Data & objects",order:5,backgroundColor:"#b93171",textColor:"#ffffff"},io:{displayName:"I/O",order:6,backgroundColor:"#6e7a24",textColor:"#ffffff"},other:{displayName:"Other",order:7,backgroundColor:"#606e8a",textColor:"#ffffff"}},a={any:"Replace me",string:"Replace me",number:1,integer:1,boolean:!0,array:[],object:{},null:null},r="https://github.com/CarlosNZ/fig-tree-evaluator",t={and:{displayName:"Logical AND",description:"True when every value is truthy — operands run in parallel",docUrl:r,backgroundColor:"#d6d0f0",textColor:"#26183f",seeds:{values:[!0,!0]},parameterDescriptions:{values:"Operands, judged by FigTree truthiness; null is falsy"}},or:{displayName:"Logical OR",description:"True when any value is truthy — operands run in parallel",docUrl:r,backgroundColor:"#cabfeb",textColor:"#26183f",seeds:{values:[!0,!1]},parameterDescriptions:{values:"Operands, judged by FigTree truthiness; null is falsy"}},not:{displayName:"Logical NOT (!)",description:"Negate the truthiness of a value",docUrl:r,backgroundColor:"#c0aee5",textColor:"#26183f",seeds:{value:!0},parameterDescriptions:{value:"Judged by FigTree truthiness; null is falsy, so not(null) is true"}},if:{displayName:"Conditional (?)",description:"Choose between two branches — only the chosen branch evaluates",docUrl:r,backgroundColor:"#ddd0f0",textColor:"#26183f",seeds:{condition:!0,then:"The condition is true",else:"The condition is false"},parameterDescriptions:{condition:"Judged by FigTree truthiness; null is falsy",then:"The value when the condition holds",else:"The value when it does not; omitted means null"}},match:{displayName:"Match",description:"Dispatch on a value — only the matching branch evaluates",docUrl:r,backgroundColor:"#d4bfeb",textColor:"#26183f",seeds:{value:"matchMe",branches:{matchMe:"YES",nonMatch:"NO"},default:"No match"},parameterDescriptions:{value:"Matched against branch keys by its canonical string form",branches:"A literal map of branches, or an expression computing one",default:"The branch taken when none matches; absent means failure"}},firstOf:{displayName:"First non-null",description:"The first candidate that is not null (SQL COALESCE) — later candidates never evaluate",docUrl:r,backgroundColor:"#ccaee5",textColor:"#26183f",seeds:{values:[null,"The first non-null value"]},parameterDescriptions:{values:"Candidates, tried in order; only null is skipped"}},equal:{displayName:"Equal (=)",description:"Are all the values equal? Deep, structural, key-order-insensitive; a cross-type comparison is false",docUrl:r,backgroundColor:"#d2efe9",textColor:"#183f3e",seeds:{values:["These are equal","These are equal"]},parameterDescriptions:{values:"The values compared; null is comparable (null equals null)",caseInsensitive:"Fold string operands to one case before comparing (shallow)"}},notEqual:{displayName:"Not equal (!=)",description:'Are the values NOT all equal? The exact negation of equal (never "all distinct")',docUrl:r,backgroundColor:"#c1e9e3",textColor:"#183f3e",seeds:{values:["These items","don't match"]},parameterDescriptions:{values:"The values compared; null is comparable (null equals null)",caseInsensitive:"Fold string operands to one case before comparing (shallow)"}},greaterThan:{displayName:"Greater than (>)",description:"Is the first value strictly greater than the second?",docUrl:r,backgroundColor:"#b0e3e0",textColor:"#183f3e",seeds:{values:[10,9]},parameterDescriptions:{values:"Exactly two operands: both numbers, or both strings (codepoint order)",nullValueDefault:"Replaces a null operand before comparing"}},greaterThanOrEqual:{displayName:"Greater than or equal (>=)",description:"Is the first value greater than or equal to the second?",docUrl:r,backgroundColor:"#d2efef",textColor:"#183f3e",seeds:{values:[10,10]},parameterDescriptions:{values:"Exactly two operands: both numbers, or both strings (codepoint order)",nullValueDefault:"Replaces a null operand before comparing"}},lessThan:{displayName:"Less than (<)",description:"Is the first value strictly less than the second?",docUrl:r,backgroundColor:"#c1e6e9",textColor:"#183f3e",seeds:{values:[9,10]},parameterDescriptions:{values:"Exactly two operands: both numbers, or both strings (codepoint order)",nullValueDefault:"Replaces a null operand before comparing"}},lessThanOrEqual:{displayName:"Less than or equal (<=)",description:"Is the first value less than or equal to the second?",docUrl:r,backgroundColor:"#b0dbe3",textColor:"#183f3e",seeds:{values:[9,9]},parameterDescriptions:{values:"Exactly two operands: both numbers, or both strings (codepoint order)",nullValueDefault:"Replaces a null operand before comparing"}},plus:{displayName:"Plus (+)",description:"Add numbers, concatenate strings or arrays, or shallow-merge objects — all operands must share one type",docUrl:r,backgroundColor:"#d7edd4",textColor:"#193e1e",seeds:{values:[1,2,3]},parameterDescriptions:{values:"The operands; homogeneous: all numbers, strings, arrays or objects",expect:"Pin the mode: every operand must be this type, and an empty input yields its identity",nullValueDefault:"Replaces any null operand before the addition"}},subtract:{displayName:"Subtract (-)",description:"Subtract one number from another",docUrl:r,backgroundColor:"#bfe4bc",textColor:"#193e1e",seeds:{value:10,minus:5},parameterDescriptions:{value:"The main operand",minus:"The amount subtracted from value"}},multiply:{displayName:"Multiply (*)",description:"Multiply numbers together — an empty input is 1, the empty product",docUrl:r,backgroundColor:"#b4e0b3",textColor:"#193e1e",seeds:{values:[5,5]},parameterDescriptions:{values:"The factors",nullValueDefault:"Replaces any null factor before multiplying"}},divide:{displayName:"Divide (/)",description:"Divide one number by another — true division; zero divisors fail",docUrl:r,backgroundColor:"#cceacd",textColor:"#193e1e",seeds:{value:100,by:10},parameterDescriptions:{value:"The main operand",by:"The divisor"}},modulo:{displayName:"Modulo",description:"The floored remainder: the result takes the sign of mod, so modulo(-7, 3) is 2",docUrl:r,backgroundColor:"#c3e7c6",textColor:"#193e1e",seeds:{value:10,mod:3},parameterDescriptions:{value:"The main operand",mod:"The modulus"}},power:{displayName:"Power (^)",description:"Raise a base to an exponent — overflow and complex results fail",docUrl:r,backgroundColor:"#acddb1",textColor:"#193e1e",seeds:{base:2,exponent:3},parameterDescriptions:{base:"The number to raise",exponent:"The power to raise it to"}},round:{displayName:"Round",description:"Round to a number of decimal places — ties go half away from zero; negative decimals round to tens, hundreds, …",docUrl:r,backgroundColor:"#d4edd8",textColor:"#193e1e",seeds:{value:3.14159,decimals:2},parameterDescriptions:{value:"The number to round",decimals:"Decimal places to keep; negative values round to powers of ten"}},floor:{displayName:"Round down",description:"Round down toward negative infinity",docUrl:r,backgroundColor:"#bce4c4",textColor:"#193e1e",seeds:{value:2.7},parameterDescriptions:{value:"The number to round down"}},ceil:{displayName:"Round up",description:"Round up toward positive infinity",docUrl:r,backgroundColor:"#b3e0be",textColor:"#193e1e",seeds:{value:2.3},parameterDescriptions:{value:"The number to round up"}},abs:{displayName:"Absolute value",description:"The absolute value",docUrl:r,backgroundColor:"#ccead5",textColor:"#193e1e",seeds:{value:-5},parameterDescriptions:{value:"The number"}},min:{displayName:"Minimum",description:"The smallest of the values — numbers numerically, strings in codepoint order",docUrl:r,backgroundColor:"#c3e7cf",textColor:"#193e1e",seeds:{values:[3,1,2]},parameterDescriptions:{values:"The candidates: all numbers, or all strings (codepoint order)",nullValueDefault:"Replaces any null candidate before comparing"}},max:{displayName:"Maximum",description:"The largest of the values — numbers numerically, strings in codepoint order",docUrl:r,backgroundColor:"#acddbf",textColor:"#193e1e",seeds:{values:[3,1,2]},parameterDescriptions:{values:"The candidates: all numbers, or all strings (codepoint order)",nullValueDefault:"Replaces any null candidate before comparing"}},buildString:{displayName:"String builder",description:"Render a template, filling its tokens — the result is always a string",docUrl:r,backgroundColor:"#f8d9c9",textColor:"#3f2f18",seeds:{template:"Hello {{$data.name}}"},parameterDescriptions:{template:"The text, with %N or {{name}} tokens; in a literal template, {{$data.x}} is that reference",substitutions:"An array pairs with %N tokens, an object with {{name}} tokens; the mode dispatches on which arrives",trim:"Trim whitespace from each rendered value, never from the template text",closeGaps:"A value that renders empty also takes one run of adjacent template whitespace",nullValueDefault:'Rendered in place of a null value, instead of ""'}},split:{displayName:"Split text",description:"Divide a string on a delimiter into an array of pieces — empty pieces are kept; an empty delimiter splits into code points",docUrl:r,backgroundColor:"#f5cbab",textColor:"#3f2f18",seeds:{value:"Alpha, Bravo, Charlie",delimiter:",",trim:!1},parameterDescriptions:{value:"The string to divide",delimiter:'Split on each occurrence; "" splits into code points',trim:"Trim whitespace from each piece"}},join:{displayName:"Join text",description:"Render array elements to text and concatenate them with a delimiter",docUrl:r,backgroundColor:"#f3cba0",textColor:"#3f2f18",seeds:{values:["Alpha","Bravo","Charlie"],delimiter:", "},parameterDescriptions:{values:'Elements of any type, rendered by the stringification table; a null renders "" and still occupies its slot',delimiter:"Placed between each adjacent pair — shares its contract with split",nullValueDefault:'Rendered in place of a null element, instead of ""'}},lower:{displayName:"Lower case",description:"Lowercase a string — Unicode default case mapping, locale-independent",docUrl:r,backgroundColor:"#f7e1bf",textColor:"#3f2f18",seeds:{value:"Hello World"},parameterDescriptions:{value:"The string to lowercase"}},upper:{displayName:"Upper case",description:"Uppercase a string — Unicode default case mapping, locale-independent",docUrl:r,backgroundColor:"#f6e1b4",textColor:"#3f2f18",seeds:{value:"Hello World"},parameterDescriptions:{value:"The string to uppercase"}},trim:{displayName:"Trim whitespace",description:"Strip whitespace (the JS trim set) from both ends of a string",docUrl:r,backgroundColor:"#f2dd97",textColor:"#3f2f18",seeds:{value:"  Hello World  "},parameterDescriptions:{value:"The string to trim"}},regex:{displayName:"Regular expression",description:"Test, extract or match a string against a regular expression",docUrl:r,backgroundColor:"#f8f1c9",textColor:"#3f2f18",seeds:{value:"test-this",pattern:"^[a-z]{4}-[a-z]{4}$",flags:"i"},parameterDescriptions:{value:"The subject string",pattern:"The regular expression source",flags:"The admitted subset: i, m, s, u",mode:"test gives a boolean, extract the first matching substring, match every one of them",noMatchDefault:"The extract answer when nothing matches — a matched empty string still passes through"}},length:{displayName:"Length",description:"An array's element count, or a string's Unicode code-point count",docUrl:r,backgroundColor:"#cde5f3",textColor:"#18293f",seeds:{value:[1,2,3,4,5]},parameterDescriptions:{value:"The array or string measured"}},map:{displayName:"Map each",description:"Transform every element of an array",docUrl:r,backgroundColor:"#bbd7ef",textColor:"#18293f",seeds:{input:[1,2,3],each:"$element",as:"item"},parameterDescriptions:{input:"The collection iterated over; a null input is a type error",as:"Rename the bindings: as: 'row' binds $row and $rowIndex",nullInputDefault:"Used as the collection when input evaluates to null — typically []",each:"Evaluated per element, with $element and $index bound"}},filter:{displayName:"Filter",description:"Keep the elements of an array whose predicate is truthy",docUrl:r,backgroundColor:"#a8c7eb",textColor:"#18293f",seeds:{input:[0,1,2,3],each:"$element",as:"item"},parameterDescriptions:{input:"The collection iterated over; a null input is a type error",as:"Rename the bindings: as: 'row' binds $row and $rowIndex",nullInputDefault:"Used as the collection when input evaluates to null — typically []",each:"The predicate, per element — a truthiness position, so null is falsy"}},find:{displayName:"Find first",description:"The first element of an array whose predicate is truthy",docUrl:r,backgroundColor:"#cddcf3",textColor:"#18293f",seeds:{input:[0,1,2,3],each:"$element",as:"item"},parameterDescriptions:{input:"The collection iterated over; a null input is a type error",as:"Rename the bindings: as: 'row' binds $row and $rowIndex",nullInputDefault:"Used as the collection when input evaluates to null — typically []",each:"The predicate, per element — a truthiness position, so null is falsy",noMatchDefault:"The answer when nothing matches; a found null passes through unchanged"}},some:{displayName:"Any match",description:"True when any element satisfies the predicate",docUrl:r,backgroundColor:"#bbccef",textColor:"#18293f",seeds:{input:[0,1,2,3],each:"$element",as:"item"},parameterDescriptions:{input:"The collection iterated over; a null input is a type error",as:"Rename the bindings: as: 'row' binds $row and $rowIndex",nullInputDefault:"Used as the collection when input evaluates to null — typically []",each:"The predicate, per element — a truthiness position, so null is falsy"}},every:{displayName:"All match",description:"True when every element satisfies the predicate",docUrl:r,backgroundColor:"#a8b9eb",textColor:"#18293f",seeds:{input:[0,1,2,3],each:"$element",as:"item"},parameterDescriptions:{input:"The collection iterated over; a null input is a type error",as:"Rename the bindings: as: 'row' binds $row and $rowIndex",nullInputDefault:"Used as the collection when input evaluates to null — typically []",each:"The predicate, per element — a truthiness position, so null is falsy"}},get:{displayName:"Get data",description:"Read a path out of the evaluation data, or out of a supplied object — the dynamic face of a $data reference",docUrl:r,backgroundColor:"#f0d1e5",textColor:"#3f182a",seeds:{path:"path.to.value",from:{path:{to:{value:"Found it"}}},default:"Not found"},parameterDescriptions:{path:"Dot and bracket segments, quoted keys and the [*] projection — or an array of segments, taken verbatim",from:"The source the path reads: a value, or a bare namespace ($data, $vars, $params, $element) whose var or parameter name opens the path — replace, never merge; a null source misses every path",default:"The answer when the path is missing — a stored null passes through unchanged (firstOf replaces one); supplying it also opts out of strictDataPaths"}},buildObject:{displayName:"Build object",description:"Assemble an object from computed key/value entries — for keys known only at runtime",docUrl:r,backgroundColor:"#eac0cc",textColor:"#3f182a",seeds:{entries:[{key:"firstKey",value:"firstValue"},{key:"secondKey",value:"secondValue"}]},parameterDescriptions:{entries:'Objects with a "key" and a "value"; a null value keeps its key'}},convert:{displayName:"Convert type",description:"Convert a value to a number, string, boolean or array — strict: a failed conversion is an error, never a guess",docUrl:r,backgroundColor:"#dddfe3",textColor:"#272a30",seeds:{value:"42"},parameterDescriptions:{value:"The value to convert; null propagates except for boolean, where it is false",to:"The target type"}},http:{displayName:"HTTP request",description:"One HTTP request — GET or POST — returning the parsed JSON response",docUrl:r,backgroundColor:"#eeedd2",textColor:"#3a3f18",seeds:{url:"https://restcountries.com/v3.1/name/zealand",returnPath:"[0].name.common",timeout:5e3},parameterDescriptions:{url:"A full http(s) URL is used verbatim; anything else — including an empty string — joins http.baseEndpoint",method:"Lowercase; the mutating verbs are deliberately absent — an expression is a read",query:"Query-string pairs; a null value omits its pair, a composite one is an error",body:"The JSON payload; a whole-null body means NO body, while nulls inside one are JSON nulls",headers:"Merged over the http.headers option per key; a null value removes an inherited pair",returnPath:"Dot/bracket path or segments array applied to the response; a miss is null",timeout:"Per-request deadline in ms; expiry is an ordinary failure this node’s fallback catches"}},graphQL:{displayName:"GraphQL query",description:"One GraphQL query — a POST of { query, variables } — returning the data field",docUrl:r,backgroundColor:"#e3e8c2",textColor:"#3a3f18",seeds:{query:'query getCountries {\n  countries(filter: { continent: { eq: "OC" } }) {\n    name\n  }\n}',url:"https://countries.trevorblades.com/",returnPath:"countries[0].name",timeout:5e3},parameterDescriptions:{query:"The GraphQL document — the protocol’s own word, as sql.query is",variables:"Query variables; a null value is CARRIED as JSON null, a nullable argument being meaningful GraphQL",url:"Per-node endpoint override; unset means the graphQL.endpoint option",headers:"Merged over http.headers then graphQL.headers; a null value removes a pair",returnPath:"Dot/bracket path or segments array applied to the response; a miss is null",timeout:"Per-request deadline in ms; expiry is an ordinary failure this node’s fallback catches"}},sql:{displayName:"SQL query",description:"One SQL query against the registered connection. Expressions are READS — give the connection a read-only role and run mutations host-side",docUrl:r,backgroundColor:"#d2e2b1",textColor:"#3a3f18",seeds:{query:"SELECT contact_name FROM customers LIMIT 5",timeout:5e3},parameterDescriptions:{query:"SQL text with the driver’s own placeholders — FigTree never parses SQL",values:"Bind values — positional as an array, named as an object; a null binds SQL NULL",shape:"rows: every row object; firstRow: the first; column: one column’s values; firstValue: one scalar",noRowDefault:"The answer when firstRow / firstValue find no row — never for rows / column, never on failure",timeout:"Per-request deadline in ms; expiry is an ordinary failure this node’s fallback catches"}},literal:{displayName:"Literal",docUrl:r,backgroundColor:"#d5dae4",textColor:"#272a30",seeds:{value:"No content inside a literal node is evaluated"}}},o=(e,a)=>void 0!==e&&Object.hasOwn(e,a)?e[a]:void 0,s=e=>void 0!==e.backgroundColor&&void 0!==e.textColor?{backgroundColor:e.backgroundColor,textColor:e.textColor}:void 0,n=(e,r,t)=>void 0!==e.seeds&&Object.hasOwn(e.seeds,r)?e.seeds[r]:"string"==typeof t?a[t]:"literal"in t?t.literal[0]:a[t.find(e=>"null"!==e)??"null"],l=(e,a)=>{for(const[r,t]of Object.entries(a??{}))void 0!==t&&(e[r]=t)},i=(a,...r)=>({categories:Object.entries(e).map(([e,a])=>({name:e,...a})).sort((e,a)=>e.order-a.order),operators:a.getOperators().map(({name:a,parameters:i,...d})=>{const c=(e=>{const a={seeds:{},parameterDescriptions:{}};for(const n of[t,...r]){const r=o(n,e);if(void 0!==r){for(const e of["displayName","description","docUrl"]){const t=r[e];void 0!==t&&(a[e]=t)}Object.assign(a,s(r)),l(a.seeds,r.seeds),l(a.parameterDescriptions,r.parameterDescriptions)}}return a})(a),u={name:a,displayName:c.displayName??a,...d,...s(c)??s(e[d.category]),parameters:{}};void 0!==c.description&&(u.description=c.description),void 0!==c.docUrl&&(u.docUrl=c.docUrl);for(const[e,a]of Object.entries(i)){const r={...a,seed:n(c,e,a.type)},t=o(c.parameterDescriptions,e);void 0!==t&&(r.description=t),u.parameters[e]=r}return u}),fragments:a.getFragments().map(({name:e,parameters:a,...r})=>{const t=r.metadata??{},o={name:e,displayName:t.displayName??e,...r,...s(t),parameters:{}};void 0!==t.docUrl&&(o.docUrl=t.docUrl);for(const[e,r]of Object.entries(a))o.parameters[e]={...r,seed:n(t,e,r.type)};return o})});export{e as categoryListings,i as getCatalog,t as operatorListings,a as typeSeeds};