@jesscss/core 2.0.0-alpha.1

package/lib/define-function.js

@@ -0,0 +1,726 @@
+import isPlainObject from 'lodash-es/isPlainObject.js';
+import { isNode } from './tree/util/is-node.js';
+import { isThenable } from '@jesscss/awaitable-pipe';
+import { List, Dimension } from './tree/index.js';
+export function defineFunction(name, fn, options) {
+    // The external API types remain exactly the same, but internal function accepts positional parameters only
+    /**
+     * Function that accepts either positional arguments or a record object.
+     * Parameter names are inferred from the params array: name, value, etc.
+     * All calls are converted to positional format before calling the internal function.
+     */
+    const result = function (...args) {
+        const rawParams = options?.params;
+        if (!rawParams) {
+            return fn(...args);
+        }
+        // Normalize params - handle overloaded signatures
+        const paramSignatures = Array.isArray(rawParams) && rawParams.length > 0 && Array.isArray(rawParams[0])
+            ? rawParams.map(sig => [...sig])
+            : [[...rawParams]];
+        // For direct calls, use the first signature (overloading handled in callWithContext)
+        const params = paramSignatures[0];
+        // Validate rest parameter position
+        validateRestParameterPosition(params);
+        // Parse arguments into a record
+        const record = parseArgumentsToRecord(args, params);
+        // Apply defaults and validate
+        applyDefaultsAndValidate(record, params);
+        // Convert to positional arguments and call internal function
+        const positionalArgs = buildPositionalArgs(record, params);
+        return fn(...positionalArgs);
+    };
+    /** Allow runtime reflection on the function */
+    return new Proxy(result, {
+        has(target, prop) {
+            if (prop === 'name' || prop === 'options') {
+                return true;
+            }
+            return prop in target;
+        },
+        get(target, prop) {
+            if (prop === 'name') {
+                return name;
+            }
+            else if (prop === 'options') {
+                return options;
+            }
+            else if (prop === '_internal') {
+                return fn;
+            }
+            return target[prop];
+        }
+    });
+}
+/** This will be called internally by Jess to functions created with defineFunction */
+export async function callWithContext(context, fn, ...args) {
+    const listArg = args.length === 1 && isNode(args[0], 'List')
+        ? args[0]
+        : undefined;
+    args = listArg ? [...listArg.value] : args;
+    // Only reject record-based calls (plain objects) when there's no params metadata
+    // Collections are allowed as positional arguments even without params metadata
+    // (e.g., detached rulesets passed to mixins)
+    if (!fn?.options?.params && args.some(arg => isPlainObject(arg) && !isNode(arg))) {
+        throw new Error('Record-based call without params is not supported');
+    }
+    /** Normalize positional args into a List node for tracking original arguments */
+    const originalArgsList = listArg
+        ? listArg.copy(true)
+        : new List(args.map(arg => isNode(arg) ? arg.clone() : arg));
+    const hasParams = !!fn?.options?.params;
+    if (!hasParams) {
+        // No metadata; treat as normal positional function call (sync or async)
+        return fn.call(context, ...args);
+    }
+    const params = fn?.options?.params;
+    const options = fn?.options;
+    // Apply preprocessParams if provided (e.g., for splitting sequences)
+    if (options?.preprocessParams && options.preprocessParams.length > 0) {
+        for (const preprocessor of options.preprocessParams) {
+            const processed = preprocessor(args, context);
+            if (isThenable(processed)) {
+                args = await processed;
+            }
+            else {
+                args = processed;
+            }
+        }
+    }
+    // Handle function overloading: params can be an array of param arrays
+    // Normalize to always be an array of signatures
+    const paramSignatures = (() => {
+        if (!params) {
+            return [];
+        }
+        // Check if params is an array of arrays (overloaded signatures)
+        if (Array.isArray(params) && params.length > 0 && Array.isArray(params[0])) {
+            return params.map(sig => [...sig]);
+        }
+        // Single signature - wrap in array
+        return [[...params]];
+    })();
+    let matchedParams;
+    let record;
+    let lastError;
+    // Try each signature until one matches
+    for (const signature of paramSignatures) {
+        try {
+            record = parseCallWithContextArgs(args, signature);
+            // Try to build positional args to validate the signature matches
+            // We'll do a dry-run validation
+            const tempRecord = { ...record };
+            let isValid = true;
+            // Check if we have a record object (plain object) in args
+            // Collections are treated as positional arguments, not record-based calls
+            const hasRecordArg = args.some(arg => isPlainObject(arg));
+            for (let i = 0; i < signature.length; i++) {
+                const def = signature[i];
+                const value = tempRecord[def.name];
+                // Check required parameters
+                if (!def.optional && !def.rest && value === undefined) {
+                    isValid = false;
+                    break;
+                }
+                // Check if we have enough arguments (skip this check if we have a record arg)
+                if (!hasRecordArg && !def.rest && i >= args.length && !def.optional) {
+                    isValid = false;
+                    break;
+                }
+            }
+            // Check if we have too many arguments (not counting rest params or record args)
+            const hasRest = signature.some(p => p.rest);
+            if (!hasRest && !hasRecordArg && args.length > signature.length) {
+                isValid = false;
+            }
+            if (isValid) {
+                matchedParams = signature;
+                break;
+            }
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+    }
+    // If no signature matched, throw an error
+    if (!matchedParams) {
+        if (lastError) {
+            throw lastError;
+        }
+        throw new Error(`No matching function signature for ${args.length} argument(s)`);
+    }
+    // Re-parse with the matched signature to ensure correct record structure
+    record = parseCallWithContextArgs(args, matchedParams);
+    /**
+     * Create FunctionThis proxy for function execution context.
+     * The args property is always a function that returns the arguments.
+     */
+    context.callStack.at(-1)?.adopt(originalArgsList);
+    const functionThis = {
+        context,
+        args: () => originalArgsList.eval(context),
+        rawArgs: originalArgsList,
+        caller: context.caller
+    };
+    // Build positional arguments with evaluation, validation, and conversion
+    const positionalArgs = await buildCallWithContextPositionalArgs(record, matchedParams, context);
+    // Call the function with the evaluated arguments
+    // Mixin functions expect Context as 'this', not FunctionThis
+    if (fn._internal) {
+        return (fn._internal).call(functionThis, ...positionalArgs);
+    }
+    else {
+        // For mixin functions and other functions that expect Context as 'this'
+        return fn.call(context, ...positionalArgs);
+    }
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Validates that rest parameters are in the correct position (last)
+ */
+function validateRestParameterPosition(params) {
+    const restIndex = params.findIndex(p => p.rest);
+    if (restIndex >= 0 && restIndex !== params.length - 1) {
+        throw new Error('Rest parameter must be the last parameter');
+    }
+}
+/**
+ * Applies conversion plugins to a value
+ */
+function applyConversionPlugins(value, plugins) {
+    let result = value;
+    // Apply conversion plugins in sequence
+    for (const plugin of plugins) {
+        result = plugin(result);
+    }
+    return result;
+}
+/**
+ * Parses function arguments into a record object
+ */
+function parseArgumentsToRecord(args, params) {
+    const record = {};
+    const restIndex = params.findIndex(p => p.rest);
+    const hasRest = restIndex >= 0;
+    // Handle pure record call (single object argument)
+    if (args.length === 1 && isPlainObject(args[0])) {
+        const isClassInstance = params?.some((opt) => {
+            const types = Array.isArray(opt.type) ? opt.type : [opt.type];
+            return types.some(type => typeof type === 'function' && args[0] instanceof type);
+        });
+        if (!isClassInstance) {
+            const input = args[0];
+            const isLateProxy = !!input && typeof input === 'object' && '_raw' in input;
+            return isLateProxy ? input._raw : { ...input };
+        }
+    }
+    // Handle hybrid call (positional + record)
+    if (args.length > 1 && isPlainObject(args[args.length - 1])) {
+        const positionalArgs = args.slice(0, -1);
+        const recordArg = args[args.length - 1];
+        // Set values from positional arguments
+        if (!hasRest) {
+            for (let i = 0; i < positionalArgs.length && i < (params?.length ?? 0); i++) {
+                const paramName = params?.[i]?.name;
+                if (paramName) {
+                    record[paramName] = positionalArgs[i];
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < (params?.length ?? 0); i++) {
+                const def = params[i];
+                const paramName = def.name;
+                if (def.rest) {
+                    record[paramName] = positionalArgs.slice(i);
+                    break;
+                }
+                else if (i < positionalArgs.length) {
+                    record[paramName] = positionalArgs[i];
+                }
+            }
+        }
+        // Override with values from record (record takes precedence)
+        Object.assign(record, recordArg);
+        return record;
+    }
+    // Handle pure positional call
+    if (!hasRest) {
+        for (let i = 0; i < Math.max(args.length, params?.length ?? 0); i++) {
+            const paramName = params?.[i]?.name;
+            if (paramName) {
+                if (i < args.length) {
+                    record[paramName] = args[i];
+                }
+                else if (params?.[i]?.default !== undefined) {
+                    record[paramName] = params[i]?.default;
+                }
+                else if (params?.[i]?.optional) {
+                    record[paramName] = undefined;
+                }
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < (params?.length ?? 0); i++) {
+            const def = params[i];
+            const paramName = def.name;
+            if (def.rest) {
+                record[paramName] = args.slice(i);
+                break;
+            }
+            else if (i < args.length) {
+                record[paramName] = args[i];
+            }
+            else if (def.default !== undefined) {
+                record[paramName] = def.default;
+            }
+            else if (def.optional) {
+                record[paramName] = undefined;
+            }
+        }
+    }
+    return record;
+}
+/**
+ * Applies defaults and validates arguments
+ */
+function applyDefaultsAndValidate(record, params) {
+    // Apply defaults for missing parameters
+    for (const paramDef of params ?? []) {
+        const paramName = paramDef.name;
+        if (record[paramName] === undefined && paramDef.default !== undefined) {
+            record[paramName] = paramDef.default;
+        }
+        // Normalize rest param to array
+        if (paramDef.rest) {
+            const current = record[paramName];
+            if (current === undefined) {
+                record[paramName] = [];
+            }
+            else if (!Array.isArray(current)) {
+                record[paramName] = [current];
+            }
+        }
+    }
+    validateArguments(record, params);
+}
+/**
+ * Builds positional arguments from record
+ */
+function buildPositionalArgs(record, params) {
+    const positionalArgs = [];
+    for (let i = 0; i < (params?.length ?? 0); i++) {
+        const def = params[i];
+        const name = def.name;
+        if (def.rest) {
+            const v = record[name];
+            const arr = Array.isArray(v) ? v : (v === undefined ? [] : [v]);
+            if (def.lazy) {
+                positionalArgs.push(...arr.map(item => createThunk(item, def)));
+            }
+            else {
+                positionalArgs.push(...arr.map((item) => {
+                    // Apply conversion plugins if defined
+                    if (def.convert && item instanceof Dimension) {
+                        return applyConversionPlugins(item, def.convert);
+                    }
+                    return item;
+                }));
+            }
+        }
+        else {
+            const v = record[name];
+            if (def.lazy) {
+                // For optional lazy parameters, if value is undefined, pass undefined directly
+                // instead of creating a thunk (which would try to call undefined())
+                if (v === undefined && (def.optional || def.default !== undefined)) {
+                    positionalArgs.push(undefined);
+                }
+                else {
+                    positionalArgs.push(createThunk(v, def));
+                }
+            }
+            else {
+                // Apply conversion plugins if defined
+                if (def.convert && v instanceof Dimension) {
+                    positionalArgs.push(applyConversionPlugins(v, def.convert));
+                }
+                else {
+                    positionalArgs.push(v);
+                }
+            }
+        }
+    }
+    return positionalArgs;
+}
+/**
+ * Parses callWithContext arguments into a record
+ */
+function parseCallWithContextArgs(args, params) {
+    const record = {};
+    const restIndex = params ? params.findIndex(p => p.rest) : -1;
+    const hasRest = (restIndex ?? -1) >= 0;
+    if (!hasRest) {
+        for (let i = 0; i < Math.min(args.length, params?.length ?? 0); i++) {
+            let arg = args[i];
+            // Collections are treated as positional arguments, not record-based calls
+            if (isPlainObject(arg) && !isNode(arg)) {
+                Object.assign(record, arg);
+                continue;
+            }
+            const paramName = params?.[i]?.name;
+            if (!paramName) {
+                throw new Error('Function does not support this number of arguments');
+            }
+            record[paramName] = args[i];
+        }
+    }
+    else {
+        for (let i = 0; i < (params?.length ?? 0); i++) {
+            const def = params[i];
+            const paramName = def.name;
+            const arg = args[i];
+            // Collections are treated as positional arguments, not record-based calls
+            if (isPlainObject(arg) && !isNode(arg)) {
+                Object.assign(record, arg);
+                continue;
+            }
+            if (def.rest) {
+                record[paramName] = args.slice(i);
+                break;
+            }
+            else {
+                record[paramName] = arg;
+            }
+        }
+    }
+    return record;
+}
+/**
+ * Builds positional arguments for callWithContext with evaluation
+ */
+async function buildCallWithContextPositionalArgs(record, params, context) {
+    const positionalArgs = [];
+    for (let i = 0; i < (params?.length ?? 0); i++) {
+        const def = params[i];
+        const name = def.name;
+        if (def.rest) {
+            const v = record[name];
+            const arr = Array.isArray(v) ? v : (v === undefined ? [] : [v]);
+            if (def.lazy) {
+                positionalArgs.push(...arr.map(item => createThunk(item, def, context)));
+            }
+            else {
+                for (const item of arr) {
+                    let processedItem = (isNode(item) && !item.evaluated) ? item.eval(context) : item;
+                    if (isThenable(processedItem)) {
+                        processedItem = await processedItem;
+                    }
+                    // Validate AFTER evaluation but BEFORE conversion
+                    validateArgumentIfNeeded(processedItem, def, 'Argument');
+                    // Apply conversion plugins if defined
+                    if (def.convert && processedItem instanceof Dimension) {
+                        processedItem = applyConversionPlugins(processedItem, def.convert);
+                    }
+                    positionalArgs.push(processedItem);
+                }
+            }
+        }
+        else {
+            const v = record[name];
+            if (def.lazy) {
+                // For optional lazy parameters, if value is undefined, pass undefined directly
+                // instead of creating a thunk (which would try to call undefined())
+                if (v === undefined && (def.optional || def.default !== undefined)) {
+                    positionalArgs.push(undefined);
+                }
+                else {
+                    positionalArgs.push(createThunk(v, def, context));
+                }
+            }
+            else {
+                let processedValue = (isNode(v) && !v.evaluated) ? v.eval(context) : v;
+                // Handle async evaluation without truncating remaining parameters.
+                if (isThenable(processedValue)) {
+                    processedValue = await processedValue;
+                }
+                // Validate AFTER evaluation but BEFORE conversion
+                validateArgumentIfNeeded(processedValue, def, 'Argument');
+                const callerName = context.caller && isNode(context.caller, 'Call')
+                    ? (typeof context.caller.value.name === 'string'
+                        ? context.caller.value.name
+                        : (isNode(context.caller.value.name, 'Reference')
+                            ? String(context.caller.value.name.value.key?.valueOf?.() ?? '')
+                            : ''))
+                    : '';
+                // Apply conversion plugins if defined
+                if (def.convert && processedValue instanceof Dimension) {
+                    processedValue = applyConversionPlugins(processedValue, def.convert);
+                }
+                positionalArgs.push(processedValue);
+            }
+        }
+    }
+    return positionalArgs;
+}
+/**
+ * Validates callWithContext arguments from record (before conversion)
+ */
+function validateCallWithContextArgs(record, params) {
+    if (!params) {
+        return;
+    }
+    for (let i = 0; i < params.length; i++) {
+        const def = params[i];
+        const value = record[def.name];
+        // Skip validation for lazy parameters since they're passed as thunks
+        if (def.lazy) {
+            continue;
+        }
+        // Skip validation for rest parameters as they're validated as arrays
+        if (def.rest) {
+            continue;
+        }
+        // Skip validation for optional parameters that are undefined
+        if (def.optional && value === undefined) {
+            continue;
+        }
+        validateArgument(value, def, 'Argument');
+    }
+}
+/**
+ * Creates a thunk function that evaluates a value and validates the result
+ */
+function createThunk(val, paramDef, context) {
+    // For direct calls without context, val should be the user's lazy function (e.g., () => new Dimension(...))
+    // NOT a thunk. We create a thunk that calls val() and validates the resolved result.
+    if (typeof val === 'function' && !context) {
+        // Create a thunk that calls val() and validates the resolved result
+        // Note: We validate the RESOLVED result when the thunk is called, not the function itself
+        return async () => {
+            const result = await val();
+            // A thunk should never return a function - if it does, that's an error
+            // Check both typeof and instanceof Function to catch all function types
+            if (typeof result === 'function' || result instanceof Function) {
+                throw new Error(`Thunk for parameter '${paramDef?.name}' returned a function. This indicates val was already a thunk, which should never happen. Original val type: ${typeof val}, result type: ${typeof result}, result constructor: ${result?.constructor?.name}`);
+            }
+            // Validate the RESOLVED result (not the function itself)
+            // This is where lazy parameter validation happens - when the thunk is called and the value is resolved
+            // Skip validation for optional parameters that are undefined
+            if (paramDef && !paramDef.rest && !(result === undefined && (paramDef.optional || paramDef.default !== undefined))) {
+                const validation = validateValue(result, paramDef.type, paramDef.name);
+                if (!validation.isValid) {
+                    throw new TypeError(validation.errorMessage);
+                }
+            }
+            return result;
+        };
+    }
+    // For callWithContext path or non-function values
+    // If val is undefined and parameter is optional, return a thunk that returns undefined
+    if (val === undefined && (paramDef?.optional || paramDef?.default !== undefined)) {
+        return async () => {
+            return undefined;
+        };
+    }
+    return async () => {
+        let result;
+        if (context && isNode(val) && !val.evaluated) {
+            result = await val.eval(context);
+        }
+        else if (typeof val === 'function') {
+            // If val is a function (lazy parameter), call it
+            result = await val();
+        }
+        else {
+            result = val;
+        }
+        // Validate the evaluated result if we have param definition
+        // Note: For lazy parameters, we validate the result of calling the function, not the function itself
+        // Skip validation for optional parameters that are undefined
+        if (paramDef && !paramDef.rest && !(result === undefined && (paramDef.optional || paramDef.default !== undefined))) {
+            const validation = validateValue(result, paramDef.type, paramDef.name);
+            if (!validation.isValid) {
+                throw new TypeError(validation.errorMessage);
+            }
+        }
+        return result;
+    };
+}
+/**
+ * Runtime validation function to check argument types and required parameters for record-based calls
+ */
+function validateArguments(record, params) {
+    if (!params) {
+        return;
+    }
+    // Check that all required parameters are provided
+    for (const paramDef of params) {
+        const paramName = paramDef.name;
+        const expectedType = paramDef.type;
+        const isOptional = paramDef.optional || paramDef.default !== undefined;
+        const value = record[paramName];
+        // Check if required parameter is missing
+        if (!isOptional && value === undefined) {
+            throw new TypeError(`Required argument '${paramName}' is missing`);
+        }
+        // Skip validation for undefined optional arguments
+        if (value === undefined) {
+            continue;
+        }
+        // For lazy parameters, validate that it's a function (validation of result happens in thunk)
+        if (paramDef.lazy) {
+            if (typeof value !== 'function') {
+                throw new TypeError(`Argument '${paramName}' must be a function (lazy parameter). Got: ${typeof value}`);
+            }
+            continue;
+        }
+        const isRest = paramDef.rest === true;
+        if (isRest) {
+            if (!Array.isArray(value)) {
+                throw new TypeError(`Argument '${paramName}' must be an array (rest parameter)`);
+            }
+            const elementTypes = Array.isArray(expectedType) ? expectedType : [expectedType];
+            for (let idx = 0; idx < value.length; idx++) {
+                const el = value[idx];
+                const isValid = (Array.isArray(elementTypes) ? elementTypes : [elementTypes]).some(type => isValidType(el, type));
+                if (!isValid) {
+                    const types = Array.isArray(elementTypes) ? elementTypes : [elementTypes];
+                    const typeList = types.map((t) => typeof t === 'function' ? t.name : t).join(', ');
+                    const actualType = typeof el === 'object' && el !== null ? el.constructor?.name || typeof el : typeof el;
+                    throw new TypeError(`Element ${idx} of '${paramName}' must be of type '${typeList}'. Got: ${actualType}`);
+                }
+            }
+        }
+        else {
+            const validation = validateValue(value, expectedType, paramName, 'Argument');
+            if (!validation.isValid) {
+                throw new TypeError(validation.errorMessage);
+            }
+        }
+    }
+}
+/**
+ * Validate argument if needed (checks for lazy and undefined values)
+ */
+function validateArgumentIfNeeded(value, def, prefix = 'Parameter') {
+    if (!def.lazy && value !== undefined) {
+        const validation = validateValue(value, def.type, def.name, prefix);
+        if (!validation.isValid) {
+            throw new TypeError(validation.errorMessage);
+        }
+    }
+}
+/**
+ * Centralized validation function
+ */
+function validateValue(value, expectedType, paramName, context = 'Argument') {
+    // Handle array of types (union types)
+    if (Array.isArray(expectedType)) {
+        const isValid = expectedType.some(type => isValidType(value, type));
+        if (!isValid) {
+            const typeList = expectedType.map((t) => typeof t === 'function' ? t.name : t).join(', ');
+            const actualType = typeof value === 'object' && value !== null ? value.constructor?.name || typeof value : typeof value;
+            return {
+                isValid: false,
+                errorMessage: `${context} '${paramName}' must be one of: ${typeList}. Got: ${actualType}`
+            };
+        }
+        return { isValid: true };
+    }
+    // Handle single type
+    if (!isValidType(value, expectedType)) {
+        const typeName = typeof expectedType === 'function' ? expectedType.name : expectedType;
+        const actualType = typeof value === 'object' && value !== null ? value.constructor?.name || typeof value : typeof value;
+        return {
+            isValid: false,
+            errorMessage: `${context} '${paramName}' must be of type '${typeName}'. Got: ${actualType}`
+        };
+    }
+    return { isValid: true };
+}
+/**
+ * Validate array elements (for rest parameters)
+ */
+function validateArrayElements(value, elementTypes, paramName, context = 'Argument') {
+    const types = Array.isArray(elementTypes) ? elementTypes : [elementTypes];
+    for (let idx = 0; idx < value.length; idx++) {
+        const el = value[idx];
+        const isValid = types.some(type => isValidType(el, type));
+        if (!isValid) {
+            const typeList = types.map((t) => typeof t === 'function' ? t.name : t).join(', ');
+            const actualType = typeof el === 'object' && el !== null ? el.constructor?.name || typeof el : typeof el;
+            return {
+                isValid: false,
+                errorMessage: `Element ${idx} of '${paramName}' must be of type '${typeList}'. Got: ${actualType}`
+            };
+        }
+    }
+    return { isValid: true };
+}
+/**
+ * Check if a value matches the expected type
+ */
+function isValidType(value, expectedType) {
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'null':
+            return value === null;
+        case 'undefined':
+            return value === undefined;
+        default:
+            // Check if it's a class constructor
+            if (typeof expectedType === 'function') {
+                return value instanceof expectedType;
+            }
+            return false;
+    }
+}
+/**
+ * Validates a single argument against its parameter definition
+ */
+function validateArgument(value, def, context = 'argument') {
+    // Skip validation for optional parameters that are undefined
+    if (def.optional && value === undefined) {
+        return;
+    }
+    // For lazy parameters, validate that it's a function
+    if (def.lazy) {
+        if (typeof value !== 'function') {
+            throw new TypeError(`${context} '${def.name}' must be a function (lazy parameter). Got: ${typeof value}`);
+        }
+        return;
+    }
+    // Validate rest parameters as arrays
+    if (def.rest) {
+        if (!Array.isArray(value)) {
+            throw new TypeError(`${context} '${def.name}' must be an array (rest parameter)`);
+        }
+        const expectedType = def.type;
+        for (let idx = 0; idx < value.length; idx++) {
+            const el = value[idx];
+            if (!isValidType(el, expectedType)) {
+                const typeName = typeof expectedType === 'function' ? expectedType.name : expectedType;
+                const actualType = typeof el === 'object' && el !== null ? el.constructor?.name || typeof el : typeof el;
+                throw new TypeError(`Element ${idx} of '${def.name}' must be of type '${typeName}'. Got: ${actualType}`);
+            }
+        }
+        return;
+    }
+    // Validate regular parameters
+    const expectedType = def.type;
+    const validation = validateValue(value, expectedType, def.name, context);
+    if (!validation.isValid) {
+        throw new TypeError(validation.errorMessage);
+    }
+}
+//# sourceMappingURL=define-function.js.map