@nejs/basic-extensions 2.21.5 → 2.22.6

package/dist/cjs/classes/param.parser.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParamParserExtensions = exports.ParamParser = void 0;
-const extension_1 = require("@nejs/extension");
-class ParamParser {
-    /**
-     * Constructs an instance of ParamParser. It takes in parameters, an optional
-     * validator function, and an optional parser function. The parameters are
-     * validated and if successful, parsed.
-     *
-     * @param {any[]} parameters - Arguments passed in by the process.
-     * @param {((any[]) => boolean)?} [validator=() => {}] - An optional function
-     * to specify a validator without subclassing ParamParser. It should return
-     * a boolean indicating the validity of the parameters.
-     * @param {((any[]) => object)?} [parser=() => {}] - An optional function to
-     * specify a parser without subclassing ParamParser. It should return an
-     * object after parsing the input parameters.
-     *
-     * @example
-     * const parameters = ['param1', 'param2']
-     * const validator = params => params.every(param => typeof param === 'string')
-     * const parser = params => ({ params })
-     * const paramParser = new ParamParser(parameters, validator, parser)
-     * if (paramParser.success) {
-     *   console.log('Parsing successful:', paramParser.results)
-     * } else {
-     *   console.error('Parsing failed.')
-     * }
-     */
-    constructor(parameters, validator = () => { }, parser = () => { }) {
-        this.args = parameters;
-        this.parser = parser;
-        this.validator = validator;
-        this.result = undefined;
-        this.success = this.validate(this.args);
-        if (this.success) {
-            this.results = this.parse(this.args);
-        }
-    }
-    /**
-     * @param {object} args arguments that were previously validated
-     * by either the overloaded validate() method or the supplied
-     * validator closure.
-     * @returns {object} returns the output object, or an empty
-     * object, after parsing the input arguments or parameters.
-     */
-    parse(args) {
-        return this.parser?.(args);
-    }
-    /**
-     * Walk the arguments and determine if the supplied input is
-     * a valid parsing.
-     *
-     * @param {any[]} args arguments supplied by the process.
-     * @returns {boolean} `true` if the validation is successful,
-     * `false` otherwise.
-     */
-    validate(args) {
-        return this.validator?.(args);
-    }
-    /**
-     * Attempts to parse the given parameters using the provided parsers, throwing an
-     * error if no valid parser is found. This method serves as a convenience wrapper
-     * around `safeTryParsers`, enforcing strict parsing by automatically enabling
-     * error throwing on failure.
-     *
-     * @param {any[]} parameters - The parameters to be parsed.
-     * @param {Function[]} parsers - An array of `ParamParser` subclasses to attempt
-     * parsing with.
-     * @returns {Object} An object containing the parsing result, with a `success`
-     * property indicating if parsing was successful, and a `data` property containing
-     * the parsed data if successful.
-     * @example
-     * const parameters = ['param1', 'param2'];
-     * const parsers = [Parser1, Parser2];
-     * const result = ParamParser.tryParsers(parameters, parsers);
-     * if (result.success) {
-     *   console.log('Parsing successful:', result.data);
-     * } else {
-     *   console.error('Parsing failed.');
-     * }
-     */
-    static tryParsers(parameters, parsers) {
-        return this.safeTryParsers(parameters, parsers, true);
-    }
-    /**
-     * Tries parsing `parameters` with each parser in `parsers`. If
-     * `throwOnFail` is true, throws an error when validation fails or
-     * no valid parser is found.
-     *
-     * This method attempts to parse the given parameters using the
-     * provided list of parsers. It validates the input to ensure both
-     * `parameters` and `parsers` are arrays and that `parsers`
-     * contains at least one valid `ParamParser` subclass. If
-     * `throwOnFail` is set to true, it will throw specific errors for
-     * invalid inputs or when no parser succeeds. Otherwise, it returns
-     * an object indicating the success status and the result of
-     * parsing, if successful.
-     *
-     * @param {any[]} parameters - The parameters to be parsed.
-     * @param {Function[]} parsers - An array of `ParamParser`
-     * subclasses to attempt parsing with.
-     * @param {boolean} [throwOnFail=false] - Whether to throw an
-     * error on failure.
-     * @returns {{success: boolean, data: any}} An object with a
-     * `success` flag and `data` containing the parsing result, if
-     * successful.
-     * @throws {ParametersMustBeArrayError} If `parameters` or
-     * `parsers` are not arrays when `throwOnFail` is true.
-     * @throws {ParsersArrayMustContainParsersError} If `parsers`
-     * does not contain at least one valid `ParamParser` subclass
-     * when `throwOnFail` is true.
-     * @throws {NoValidParsersFound} If no valid parser is found
-     * and `throwOnFail` is true.
-     * @example
-     * const parameters = ['param1', 'param2'];
-     * const parsers = [Parser1, Parser2];
-     * const result = ParamParser.safeTryParsers(
-     *   parameters, parsers, true
-     * );
-     *
-     * if (result.success) {
-     *   console.log('Parsing successful:', result.data);
-     * } else {
-     *   console.error('Parsing failed.');
-     * }
-     */
-    static safeTryParsers(parameters, parsers, throwOnFail = false) {
-        if (!Array.isArray(parameters) || !Array.isArray(parsers)) {
-            if (throwOnFail) {
-                throw new this.ParametersMustBeArrayError(`${this.name}.tryParsers must receive two arrays as args`);
-            }
-        }
-        if (!parsers.some(parser => parser?.prototype instanceof ParamParser &&
-            typeof parser === 'function')) {
-            if (throwOnFail) {
-                throw new this.ParsersArrayMustContainParsersError(`${this.name}.tryParsers parsers argument must contain at least one ` +
-                    `ParamParser derived class`);
-            }
-        }
-        let success = false;
-        let result = undefined;
-        for (let Parser of parsers) {
-            const parser = new Parser(parameters);
-            if (parser.success) {
-                success = true;
-                result = parser.result;
-                break;
-            }
-        }
-        if (!success && throwOnFail) {
-            throw new this.NoValidParsersFound('No valid parsers found');
-        }
-        return { success, data: result };
-    }
-    /**
-     * A custom error class that signifies no valid parsers were found
-     * during the parsing process. This error is thrown when all
-     * parsers fail to parse the given parameters and the `throwOnFail`
-     * flag is set to true in the `safeTryParsers` method.
-     *
-     * @returns {Function} A class extending Error, representing a
-     * specific error when no valid parsers are found.ound.
-     *
-     * @example
-     * try {
-     *   const result = ParamParser.safeTryParsers(
-     *     parameters, parsers, true
-     *   );
-     * } catch (error) {
-     *   if (error instanceof ParamParser.NoValidParsersFound) {
-     *     console.error(
-     *       'No valid parsers could process the parameters.'
-     *     );
-     *   }
-     * }
-     */
-    static get NoValidParsersFound() {
-        return class NoValidParsersFound extends Error {
-        };
-    }
-    /**
-     * Represents an error thrown when the parameters provided to a method
-     * are not in an array format as expected. This class extends the
-     * native JavaScript `Error` class, allowing for instances of this
-     * error to be thrown and caught using standard error handling
-     * mechanisms in JavaScript.
-     *
-     * This error is specifically used in scenarios where a method
-     * expects its arguments to be provided as an array, and the
-     * validation of those arguments fails because they were not
-     * provided in an array format. It serves as a clear indicator
-     * of the nature of the error to developers, enabling them to
-     * quickly identify and rectify the issue in their code.
-     *
-     * @example
-     * try {
-     *   ParamParser.safeTryParsers(nonArrayParameters, parsers, true);
-     * } catch (error) {
-     *   if (error instanceof ParamParser.ParametersMustBeArrayError) {
-     *     console.error('Parameters must be provided as an array.');
-     *   }
-     * }
-     */
-    static get ParametersMustBeArrayError() {
-        return class ParametersMustBeArrayError extends Error {
-        };
-    }
-    /**
-     * A custom error class indicating that the parsers array does not
-     * contain valid parser functions. This error is thrown when the
-     * validation of parsers within `ParamParser.safeTryParsers` fails
-     * to find any instance that is a subclass of `ParamParser`. It
-     * extends the native JavaScript `Error` class, allowing it to be
-     * thrown and caught using standard error handling mechanisms.
-     *
-     * This error serves as a clear indicator to developers that the
-     * provided array of parsers does not meet the expected criteria,
-     * specifically that it must contain at least one valid parser
-     * that extends `ParamParser`. This ensures that the parsing
-     * process can be executed with at least one valid parser function.
-     *
-     * @example
-     * try {
-     *   ParamParser.safeTryParsers(parameters, [], true);
-     * } catch (error) {
-     *   const { ParsersArrayMustContainParsersError } = ParamParser
-     *   if (error instanceof ParsersArrayMustContainParsersError) {
-     *     console.error(
-     *       'The parsers array must contain at least one valid parser.'
-     *     );
-     *   }
-     * }
-     */
-    static get ParsersArrayMustContainParsersError() {
-        return class ParsersArrayMustContainParsersError extends Error {
-        };
-    }
-}
-exports.ParamParser = ParamParser;
-exports.ParamParserExtensions = new extension_1.Extension(ParamParser);
-//# sourceMappingURL=param.parser.js.map

package/dist/cjs/classes/param.parser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"param.parser.js","sourceRoot":"","sources":["../../../src/classes/param.parser.js"],"names":[],"mappings":"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"}

package/dist/cjs/classes/pluggable.proxy.d.ts

@@ -1,153 +0,0 @@
-export class ProxyHandlerResponse {
-    [x: symbol]: string;
-    constructor(success?: boolean, value?: undefined, context?: undefined);
-}
-export class ProxyHandler {
-    /**
-     * This static method is used to create a response object. The response
-     * object contains the success status, the value, and the context of the
-     * response. It also includes a getter for the Symbol.toStringTag property
-     * that returns the ResponseType of the ProxyHandler.
-     *
-     * @param {boolean} success - The success status of the response.
-     * @param {*} value - The value of the response.
-     * @param {Object} context - The context of the response.
-     * @returns {Object} The response object.
-     *
-     * @example
-     * // Create a response object
-     * const response = ProxyHandler.response(
-     *   true, 'value', { key: 'context' }
-     * );
-     *
-     * // Output: { success: true, value: 'value', context: { key: 'context' },
-     * //           [Symbol.toStringTag]: 'ProxyHandlerResponse' }
-     * console.log(response);
-     */
-    static response(success: boolean, value: any, context: Object): Object;
-    /**
-     * This static getter method is used to retrieve the response type
-     * of the ProxyHandler. It returns a string that represents the
-     * response type of the ProxyHandler.
-     *
-     * @property {function} ResponseType - A static getter method that
-     * returns the response type of the ProxyHandler.
-     * @returns {string} A string representing the response type of the
-     * ProxyHandler.
-     *
-     * @example
-     * // Get the response type of the ProxyHandler
-     * const responseType = ProxyHandler.ResponseType;
-     *
-     * // Output: 'ProxyHandlerResponse'
-     * console.log(responseType);
-     */
-    static get ResponseType(): string;
-    /**
-     * This static method is used to retrieve the name of a ProxyHandler type
-     * from a given array of arguments. If the array of arguments matches any
-     * of the ProxyHandler types, the name of that type is returned. If no
-     * match is found, or if the input is not an array, 'custom' is returned.
-     *
-     * @param {Array.<*>} proxyHandlerType - An array of arguments to match
-     * against the ProxyHandler types.
-     * @returns {string} The name of the matching ProxyHandler type, or 'custom'
-     * if no match is found.
-     *
-     * @example
-     * // Get the name of a type from its arguments
-     * const typeName = ProxyHandler.nameFromType(
-     *   ['target', 'thisArg', 'argumentsList']
-     * );
-     *
-     * // Output: 'apply'
-     * console.log(typeName);
-     *
-     * @throws {TypeError} If ProxyHandler.type is undefined.
-     */
-    static nameFromType(proxyHandlerType: Array<any>): string;
-    /**
-     * This method is used to retrieve all the types of ProxyHandler available
-     * in the ProxyHandler.type object. It is useful when you need to iterate
-     * over all the types or when you need to check if a certain type exists.
-     *
-     * @property {function} typeNames - A static getter method that returns an
-     * array of keys from the ProxyHandler.type object.
-     * @returns {Array.<string>} An array of strings representing the keys of
-     * the ProxyHandler.type object.
-     *
-     * @example
-     * // Get all type names
-     * const types = ProxyHandler.typeNames;
-     *
-     * // Output: ['apply', 'construct', 'defineProperty', ...]
-     * console.log(types);
-     *
-     * @throws {TypeError} If ProxyHandler.type is undefined.
-     */
-    static get typeNames(): Array<string>;
-    /**
-     * A static getter method that returns an object containing keyed proxy
-     * trap types and their associated expected arguments list by name. A
-     * docstring description complete with url shortening links for each entry
-     * are provided (links go to the MDN documentation)
-     *
-     * @property {function} type - A static getter method that returns an object
-     * of ProxyHandler types.
-     * @returns {Object.<string, function>} An object where each key is a type
-     * name and each value is a function that returns an array of strings
-     * representing the arguments for that type.
-     *
-     * @example
-     * // Get the 'apply' type
-     * const applyType = ProxyHandler.type.apply;
-     *
-     * // Output: ['target', 'thisArg', 'argumentsList']
-     * console.log(applyType());
-     *
-     * @throws {TypeError} If ProxyHandler.type is undefined.
-     */
-    static get type(): {
-        [x: string]: Function;
-    };
-    constructor(handler: any, type?: Function);
-    handler: any;
-    typeName: string;
-    type: any;
-    invoke(...args: any[]): any;
-}
-export class PluggableProxy {
-    static get kCreated(): symbol;
-    static get kOriginal(): symbol;
-    static get kProxy(): symbol;
-    constructor(Class: any, handlers: any, options?: {
-        prototype: undefined;
-        apply: boolean;
-    });
-    handlers: Map<any, any>;
-    handlersOfType(typeName: any): any;
-    tryEachOfType(type: any, ...args: any[]): any[];
-    apply(target: any, thisArg: any, argumentsList: any): any;
-    construct(target: any, args: any): any;
-    defineProperty(target: any, key: any, descriptor: any): any;
-    deleteProperty(target: any, property: any): any;
-    get(target: any, property: any, receiver: any): any;
-    getOwnPropertyDescriptor(target: any, property: any): any;
-    getPrototypeOf(target: any): any;
-    has(target: any, property: any): any;
-    isExtensible(target: any): any;
-    ownKeys(target: any): any;
-    preventExtensions(target: any): any;
-    set(target: any, property: any, value: any, receiver: any): any;
-    setPrototypeOf(target: any, prototype: any): any;
-}
-export const ProxyHandlerExtensions: Extension;
-export const PluggableProxyExtensions: Extension;
-export const PluggableProxyExtensionSet: {
-    name: string;
-    extensionObjects: Set<any>;
-    extensions: Set<any>;
-    apply(): void;
-    revert(): void;
-};
-import { Extension } from '@nejs/extension';