nuxeo-development-framework 6.1.5 → 6.1.7

package/lib/shared/evaluator/evaluator.d.ts

@@ -1,79 +0,0 @@
-import { EvaluatorOptions, TemplateSettings } from './types';
-/**
- * A utility class for evaluating expressions, interpolating strings, and working with templates.
- * This class provides static methods for dynamic evaluation of code, string interpolation,
- * and template processing with caching capabilities.
- */
-export declare class Evaluator {
-    /**
-     * Cache for storing compiled template functions to improve performance.
-     * Keys are string hashes of the template, values are the compiled functions.
-     */
-    static cache: Record<string, Function>;
-    /**
-     * Settings for template processing, defining regex patterns for different template operations.
-     * - interpolate: Pattern for variable interpolation ({{ variable }})
-     * - evaluate: Pattern for code evaluation ({% code %})
-     * - escape: Pattern for HTML escaping ({{{ variable }}})
-     */
-    static templateSettings: TemplateSettings;
-    /**
-     * Creates a function from a string or returns the function if already provided.
-     * Uses a secure context to prevent access to the window object by default.
-     * @param {string|Function} func - The function or string to convert to a function.
-     * @param {...any} params - The parameters to pass to the function.
-     * @param {EvaluatorOptions} [options={}] - Optional configuration for the evaluation.
-     * @returns {Function} - The resulting function.
-     */
-    static evaluator(func: string | Function, ...params: any[]): Function;
-    /**
-     * Replaces template expressions in a string with values from data.
-     * Supports function calls within templates and fallback values using || syntax.
-     * By default, ensures evaluation happens in a secure context to prevent access to window object.
-     * @param {string} rawTemplate - The template string containing expressions to interpolate.
-     * @param {Record<string, any>} data - The data object containing values to use for interpolation.
-     * @param {EvaluatorOptions} [options={}] - Optional configuration for the interpolation process.
-     * @returns {string} - The interpolated string with all expressions replaced with actual values.
-     */
-    static interpolateString(rawTemplate: string, data: Record<string, any>, options?: EvaluatorOptions): string;
-    /**
-     * Performs an evaluation using the evaluation context of this component.
-     * By default, ensures evaluation happens in a secure context to prevent access to window object.
-     * @param {string|Function|object} func - The function or string to evaluate.
-     * @param {object} args - The arguments to pass to the evaluation.
-     * @param {string} ret - The name of the variable within the evaluation context to return.
-     * @param {boolean} interpolate - Determines if it should replace all {{ }} token references with actual data.
-     * @param {object} context -   - The evaluation context.
-     * @param {EvaluatorOptions } options - The options to pass to the evaluation.
-     * @returns {*} - The result of the evaluation.
-     */
-    static evaluate(func: any, args?: Record<string, any>, ret?: string, interpolate?: boolean, context?: Record<string, any>, options?: EvaluatorOptions): any;
-    /**
-     * Executes a function with provided arguments and context.
-     * By default, ensures execution happens in a secure context to prevent access to window object.
-     * @param {Function} func - The function to execute.
-     * @param {any[]|Record<string, any>} args - The arguments to pass to the function, either as an array or object.
-     * @param {Record<string, any>} [context={}] - The context (this) to use when executing the function.
-     * @param {EvaluatorOptions} [options={}] - Optional configuration for the execution.
-     * @returns {any} - The result of the function execution.
-     */
-    static execute(func: Function, args: any[] | Record<string, any>, context?: Record<string, any>, options?: EvaluatorOptions): any;
-    /**
-     * Creates a template function from a string with caching for performance.
-     * By default, ensures the template function executes in a secure context.
-     * @param {string} template - The template string to compile into a function.
-     * @param {string} [hash] - Optional hash to use as cache key. If not provided, a hash will be generated from the template.
-     * @param {EvaluatorOptions} [options={}] - Optional configuration for the template.
-     * @returns {Function|undefined} - The compiled template function, or undefined if compilation fails.
-     */
-    static template(template: string, hash?: string, options?: EvaluatorOptions): Function | undefined;
-    /**
-     * Interpolates a template with data, handling both function templates and string templates.
-     * By default, ensures interpolation happens in a secure context to prevent access to window object.
-     * @param {string|Function} rawTemplate - The template to interpolate, either as a string or a function.
-     * @param {Record<string, any>} data - The data object to use for interpolation.
-     * @param {EvaluatorOptions} options - Options for the interpolation process.
-     * @returns {string|any} - The result of the interpolation, typically a string but could be any type depending on the template.
-     */
-    static interpolate(rawTemplate: string | Function, data: Record<string, any>, options?: EvaluatorOptions): string | any;
-}

package/lib/shared/evaluator/index.d.ts

@@ -1,2 +0,0 @@
-export * from './evaluator';
-export * from './types';

package/lib/shared/evaluator/types.d.ts

@@ -1,18 +0,0 @@
-export declare type EvaluatorOptions = {
-    data?: Record<string, any>;
-    /**
-     * Controls the security level of evaluation.
-     * - 'secure' (default): Prevents access to window object and other global objects
-     * - 'unsafe': Allows access to all global objects (use with caution)
-     */
-    securityMode?: 'secure' | 'unsafe';
-};
-export declare type TemplateSettings = {
-    interpolate: RegExp;
-    evaluate: RegExp;
-    escape: RegExp;
-};
-export declare type InterpolateString = string;
-export declare type EvaluatedString<VAR extends string = 'show'> = `${string}${VAR}${Whitespace}=${Whitespace}${string}`;
-declare type Whitespace = '' | ' ' | `${any}`;
-export {};