configorama 0.6.19 → 0.7.1

package/types/src/main.d.ts

@@ -0,0 +1,275 @@
+export = Configorama;
+declare class Configorama {
+    constructor(fileOrObject: any, opts: any);
+    settings: any;
+    filterCache: {};
+    foundVariables: any[];
+    fileRefsFound: any[];
+    resolutionTracking: {};
+    variableSyntax: RegExp;
+    varPrefix: string;
+    varSuffix: string;
+    varPrefixPattern: RegExp;
+    varSuffixPattern: RegExp;
+    varSuffixWithSpacePattern: RegExp;
+    config: any;
+    originalConfig: any;
+    configPath: any;
+    configFilePath: string;
+    configFileType: string;
+    originalString: string;
+    tracker: PromiseTracker;
+    variableTypes: any;
+    variablesKnownTypes: RegExp;
+    filters: any;
+    filterMatch: RegExp;
+    functions: any;
+    deep: any[];
+    leaves: any[];
+    callCount: number;
+    /**
+     * Populate all variables in the service, conveniently remove and restore the service attributes
+     * that confuse the population methods.
+     * @param cliOpts An options hive to use for ${opt:...} variables.
+     * @returns {Promise<any>} A promise resolving to the populated service.
+     */
+    init(cliOpts: any): Promise<any>;
+    options: any;
+    configFileContents: string;
+    rawOriginalConfig: any;
+    /**
+     * Collect metadata about all variables found in the configuration
+     * @returns {object} Metadata object containing variables, fileRefs, and summary
+     */
+    collectVariableMetadata(): object;
+    _cachedMetadata: {
+        variables: {};
+        uniqueVariables: {};
+        fileDependencies: {
+            globPatterns: any[];
+            dynamicPaths: any[];
+            resolvedPaths: any[];
+            byConfigPath: any[];
+            references: any[];
+        };
+        summary: {
+            totalVariables: number;
+            requiredVariables: number;
+            variablesWithDefaults: number;
+        };
+    };
+    /**
+     * Populate the variables in the given object.
+     * @param objectToPopulate The object to populate variables within.
+     * @returns {Promise<any>} A promise resolving to the in-place populated object.
+     */
+    populateObject(objectToPopulate: any): Promise<any>;
+    populateObjectImpl(objectToPopulate: any): any;
+    /**
+     * The declaration of a terminal property.  This declaration includes the path and value of the
+     * property.
+     * Example Input:
+     * {
+     *   foo: {
+     *     bar: 'baz'
+     *   }
+     * }
+     * Example Result:
+     * [
+     *   {
+     *     path: ['foo', 'bar']
+     *     value: 'baz
+     *   }
+     * ]
+     * @typedef {Object} TerminalProperty
+     * @property {String[]} path The path to the terminal property
+     * @property {Date|RegExp|String} value The value of the terminal property
+     */
+    /**
+     * Generate an array of objects noting the terminal properties of the given root object and their
+     * paths
+     * @param root The object to generate a terminal property path/value set for
+     * @param current The current part of the given root that terminal properties are being sought
+     * within
+     * @param [context] An array containing the path to the current object root (intended for internal
+     * use)
+     * @param [results] An array of current results (intended for internal use)
+     * @returns {TerminalProperty[]} The terminal properties of the given root object, with the path
+     * and value of each
+     */
+    getProperties(root: any, atRoot: any, current: any, _context: any, _results: any): {
+        /**
+         * The path to the terminal property
+         */
+        path: string[];
+        /**
+         * The value of the terminal property
+         */
+        value: Date | RegExp | string;
+    }[];
+    /**
+     * @typedef {TerminalProperty} TerminalPropertyPopulated
+     * @property {Object} populated The populated value of the value at the path
+     */
+    /**
+     * Populate the given terminal properties, returning promises to do so
+     * @param properties The terminal properties to populate
+     * @returns {Promise<TerminalPropertyPopulated[]>[]} The promises that will resolve to the
+     * populated values of the given terminal properties
+     */
+    populateVariables(properties: any): Promise<{
+        /**
+         * The path to the terminal property
+         */
+        path: string[];
+        /**
+         * The value of the terminal property
+         */
+        value: Date | RegExp | string;
+    }[]>[];
+    /**
+     * Assign the populated values back to the target object
+     * @param target The object to which the given populated terminal properties should be applied
+     * @param populations The fully populated terminal properties
+     * @returns {Promise<void>} resolving when changes have been applied to the given target
+     */
+    assignProperties(target: any, populations: any): Promise<void>;
+    /**
+     * @typedef {Object} MatchResult
+     * @property {String} match The original property value that matched the variable syntax
+     * @property {String} variable The cleaned variable string that specifies the origin for the
+     * property value
+     */
+    /**
+     * Get matches against the configured variable syntax
+     * @param property The property value to attempt extracting matches from
+     * @returns {Object|String|MatchResult[]} The given property or the identified matches
+     */
+    getMatches(property: any): any | string | {
+        /**
+         * The original property value that matched the variable syntax
+         */
+        match: string;
+        /**
+         * The cleaned variable string that specifies the origin for the
+         * property value
+         */
+        variable: string;
+    }[];
+    /**
+     * Populate the given matches, returning an array of Promises which will resolve to the populated
+     * values of the given matches
+     * @param {MatchResult[]} matches The matches to populate
+     * @returns {Promise[]} Promises for the eventual populated values of the given matches
+     */
+    populateMatches(matches: {
+        /**
+         * The original property value that matched the variable syntax
+         */
+        match: string;
+        /**
+         * The cleaned variable string that specifies the origin for the
+         * property value
+         */
+        variable: string;
+    }[], valueObject: any, root: any): Promise<any>[];
+    /**
+     * Render the given matches and their associated results to the given value
+     * @param value The value into which to render the given results
+     * @param matches The matches on the given value where the results are to be rendered
+     * @param results The results that are to be rendered to the given value
+     * @returns {*} The populated value with the given results rendered according to the given matches
+     */
+    renderMatches(valueObject: any, matches: any, results: any): any;
+    /**
+     * Populate the given value, recursively if root is true
+     * @param valueObject The value to populate variables within
+     * @param root Whether the caller is the root populater and thereby whether to recursively
+     * populate
+     * @returns {Promise<any>} A promise that resolves to the populated value, recursively if root
+     * is true
+     */
+    populateValue(valueObject: any, root: any, caller: any): Promise<any>;
+    /**
+     * Populate variables in the given property.
+     * @param propertyToPopulate The property to populate (replace variables with their values).
+     * @returns {Promise.<TResult>|*} A promise resolving to the populated result.
+     */
+    /**
+     * Split the cleaned variable string containing one or more comma delimited variables and get a
+     * final value for the entirety of the string
+     * @param variable The variable string to split and get a final value for
+     * @param property The original property string the given variable was extracted from
+     * @returns {Promise} A promise resolving to the final value of the given variable
+     */
+    splitAndGet(variable: any, valueObject: any, root: any, originalVar: any): Promise<any>;
+    /**
+     * Populate a given property, given the matched string to replace and the value to replace the
+     * matched string with.
+     * @param {object} valueObject The value object containing the property to populate
+     * @param {any} valueObject.value The property to replace the matched string with the value.
+     * @param {string[]} [valueObject.path] The path to the value in the config.
+     * @param {string} [valueObject.originalSource] The original source string.
+     * @param {Array} [valueObject.resolutionHistory] History of resolution steps.
+     * @param matchedString The string in the given property that was matched and is to be replaced.
+     * @param valueToPopulate The value to replace the given matched string in the property with.
+     * @returns {{value: any, path?: string[], originalSource?: string, resolutionHistory?: Array, __internal_only_flag?: boolean, caller?: string, count?: number}} The populated property object
+     */
+    populateVariable(valueObject: {
+        value: any;
+        path?: string[];
+        originalSource?: string;
+        resolutionHistory?: any[];
+    }, matchedString: any, valueToPopulate: any): {
+        value: any;
+        path?: string[];
+        originalSource?: string;
+        resolutionHistory?: any[];
+        __internal_only_flag?: boolean;
+        caller?: string;
+        count?: number;
+    };
+    /**
+     * Resolve the given variable string that expresses a series of fallback values in case the
+     * initial values are not valid, resolving each variable and resolving to the first valid value.
+     * @param variableStrings The overwrite string of variables to populate and choose from.
+     * @param valueObject The value object
+     * @param originalVar The original variable string
+     * @returns {Promise<any>} A promise resolving to the first validly populating variable
+     *  in the given variable strings string.
+     */
+    overwrite(variableStrings: any, valueObject: any, originalVar: any): Promise<any>;
+    /**
+     * Given any variable string, return the value it should be populated with.
+     * @param variableString The variable string to retrieve a value for.
+     * @param valueObject The value object
+     * @param caller The caller name
+     * @param originalVar The original variable string
+     * @returns {Promise<any>} A promise resolving to the given variables value.
+     */
+    getValueFromSource(variableString: any, valueObject: any, caller: any, originalVar: any): Promise<any>;
+    getValueFromSelf(variableString: any, o: any, x: any, data: any): Promise<any>;
+    getValueFromFile(variableString: any, options: any): any;
+    getValueFromDeep(variableString: any, pathValue: any): Promise<any>;
+    getVariableFromDeep(variableString: any): any;
+    makeDeepVariable(variable: any, caller: any): any;
+    /**
+     * Get a value that is within the given valueToPopulate.  The deepProperties specify what value
+     * to retrieve from the given valueToPopulate.  The trouble is that anywhere along this chain a
+     * variable can be discovered.  If this occurs, to avoid cyclic dependencies, the resolution of
+     * the deep value from the given valueToPopulate must be halted.  The discovered variable is thus
+     * set aside into a "deep variable" (see makeDeepVariable).  The indexing into the given
+     * valueToPopulate is then resolved with a replacement ${deep:${index}.${remaining.properties}}
+     * variable (e.g. ${deep:1.foo}).  This pauses the population for continuation during the next
+     * generation of evaluation (see getValueFromDeep)
+     * @param deepProperties The "path" of properties to follow in obtaining the deeper value
+     * @param valueToPopulate The value from which to obtain the deeper value
+     * @returns {Promise} A promise resolving to the deeper value or to a `deep` variable that
+     * will later resolve to the deeper value
+     */
+    getDeeperValue(deepProperties: any, valueToPopulate: any): Promise<any>;
+    initialCall(func: any): any;
+    runFunction(variableString: any): any;
+}
+import PromiseTracker = require("./utils/PromiseTracker");
+//# sourceMappingURL=main.d.ts.map

package/types/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA6HA;IACE,0CAgaC;IAxZC,cAaW;IAOX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAsGC;IAoED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAMpB;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CA+Kb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAofxB;IACD,+EA8BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAoDC;CACF"}

package/types/src/parsers/esm.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Execute ESM file and return its export using jiti
+ * @param {string} filePath - Full path to the ESM file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @returns {Promise<*>} The result of executing the ESM file
+ */
+export function executeESMFile(filePath: string, opts?: any): Promise<any>;
+/**
+ * Synchronous ESM file execution using jiti
+ * @param {string} filePath - Full path to the ESM file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @returns {*} The result of executing the ESM file
+ */
+export function executeESMFileSync(filePath: string, opts?: any): any;
+//# sourceMappingURL=esm.d.ts.map

package/types/src/parsers/esm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm.d.ts","sourceRoot":"","sources":["../../../src/parsers/esm.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CA0BtB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,eAEJ,GAAC,CAyBb"}

package/types/src/parsers/hcl.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=hcl.d.ts.map

package/types/src/parsers/hcl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.js"],"names":[],"mappings":""}

package/types/src/parsers/index.d.ts

@@ -0,0 +1,18 @@
+declare namespace _exports {
+    export { ParserFunction };
+}
+declare const _exports: {
+    [x: string]: ParserFunction;
+};
+export = _exports;
+type ParserFunction = {
+    /**
+     * - Parse string content into object
+     */
+    parse: Function;
+    /**
+     * - Convert object to string format
+     */
+    stringify: Function;
+};
+//# sourceMappingURL=index.d.ts.map

package/types/src/parsers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/parsers/index.js"],"names":[],"mappings":""}

package/types/src/parsers/ini.d.ts

@@ -0,0 +1,6 @@
+export function parse(contents: any): any;
+export function dump(object: any): any;
+export function toYaml(iniContents: any): string;
+export function toJson(iniContents: any): string;
+export { toYaml as toYml };
+//# sourceMappingURL=ini.d.ts.map

package/types/src/parsers/ini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ini.d.ts","sourceRoot":"","sources":["../../../src/parsers/ini.js"],"names":[],"mappings":"AAIA,0CAQC;AAED,uCAQC;AAED,iDAQC;AAED,iDAQC"}

package/types/src/parsers/json5.d.ts

@@ -0,0 +1,10 @@
+export function parse(contents: any): any;
+export function dump(object: any): string;
+export function toYaml(jsonContents: any): string;
+export function toToml(jsonContents: any): string;
+export declare let stringify: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export { toYaml as toYml };
+//# sourceMappingURL=json5.d.ts.map

package/types/src/parsers/json5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json5.d.ts","sourceRoot":"","sources":["../../../src/parsers/json5.js"],"names":[],"mappings":"AAIA,0CAQC;AAED,0CAQC;AAED,kDAQC;AAED,kDAQC"}

package/types/src/parsers/toml.d.ts

@@ -0,0 +1,7 @@
+export function parse(contents: any): TOML.JsonMap;
+export function dump(object: any): string;
+export function toYaml(tomlContents: any): string;
+export function toJson(tomlContents: any): string;
+import TOML = require("@iarna/toml");
+export { toYaml as toYml };
+//# sourceMappingURL=toml.d.ts.map

package/types/src/parsers/toml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml.d.ts","sourceRoot":"","sources":["../../../src/parsers/toml.js"],"names":[],"mappings":"AAIA,mDAQC;AAED,0CAQC;AAED,kDAQC;AAED,kDAQC"}

package/types/src/parsers/typescript.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Load TypeScript file and return its export (without executing)
+ * @param {string} filePath - Full path to the TypeScript file
+ * @param {Object} opts - Additional options (unused, kept for API compat)
+ * @returns {Promise<*>} The exported module from the TypeScript file
+ */
+export function executeTypeScriptFile(filePath: string, opts?: any): Promise<any>;
+/**
+ * Load TypeScript file synchronously and return its export
+ * @param {string} filePath - Full path to the TypeScript file
+ * @param {Object} opts - Additional options (unused, kept for API compat)
+ * @returns {*} The exported module from the TypeScript file
+ */
+export function executeTypeScriptFileSync(filePath: string, opts?: any): any;
+//# sourceMappingURL=typescript.d.ts.map

package/types/src/parsers/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/parsers/typescript.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CAwDtB;AAED;;;;;GAKG;AACH,oDAJW,MAAM,eAEJ,GAAC,CAwDb"}

package/types/src/parsers/yaml.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pre-process YAML string to handle nested variables and CloudFormation syntax
+ * @param {string} [ymlStr=''] - YAML string to pre-process
+ * @returns {string} Pre-processed YAML string
+ */
+export function preProcess(ymlStr?: string): string;
+/**
+ * Parse YAML content into JavaScript object
+ * @param {string} ymlContents - YAML string to parse
+ * @returns {Object} Parsed YAML object
+ * @throws {Error} If YAML parsing fails
+ */
+export function parse(ymlContents: string): any;
+/**
+ * Loader for custom CF syntax
+ * @param {string|Buffer} contents - YAML content to load
+ * @param {Object} [options] - YAML load options
+ * @returns {{data: Object|null, error: Error|null}} Parsed data and error if any
+ */
+export function load(contents: string | Buffer, options?: any): {
+    data: any | null;
+    error: Error | null;
+};
+/**
+ * Convert JavaScript object to YAML string
+ * @param {Object} object - Object to convert to YAML
+ * @returns {string} YAML string representation
+ * @throws {Error} If conversion fails
+ */
+export function dump(object: any): string;
+/**
+ * Convert YAML content to TOML format
+ * @param {string} ymlContents - YAML string to convert
+ * @returns {string} TOML string representation
+ * @throws {Error} If conversion fails
+ */
+export function toToml(ymlContents: string): string;
+/**
+ * Convert YAML content to JSON format
+ * @param {string} ymlContents - YAML string to convert
+ * @returns {string} JSON string representation
+ * @throws {Error} If conversion fails
+ */
+export function toJson(ymlContents: string): string;
+//# sourceMappingURL=yaml.d.ts.map

package/types/src/parsers/yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../../../src/parsers/yaml.js"],"names":[],"mappings":"AAiGA;;;;GAIG;AACH,oCAHW,MAAM,GACJ,MAAM,CA4FlB;AA1KD;;;;;GAKG;AACH,mCAJW,MAAM,OAahB;AAhCD;;;;;GAKG;AACH,+BAJW,MAAM,GAAC,MAAM,kBAEX;IAAC,IAAI,EAAE,MAAO,IAAI,CAAC;IAAC,KAAK,EAAE,KAAK,GAAC,IAAI,CAAA;CAAC,CAWlD;AAmBD;;;;;GAKG;AACH,mCAHa,MAAM,CAalB;AAED;;;;;GAKG;AACH,oCAJW,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;GAKG;AACH,oCAJW,MAAM,GACJ,MAAM,CAWlB"}

package/types/src/resolvers/valueFromCron.d.ts

@@ -0,0 +1,14 @@
+declare const cronRefSyntax: RegExp;
+declare function getValueFromCron(variableString: any): string | Promise<any>;
+/**
+ * Convert human-readable strings to cron expressions
+ * Based on common patterns and schedules
+ */
+declare function parseCronExpression(input: any): any;
+export declare let type: string;
+export declare let source: string;
+export declare let prefix: string;
+export declare let syntax: string;
+export declare let description: string;
+export { cronRefSyntax as match, getValueFromCron as resolver, parseCronExpression as _parseCronExpression };
+//# sourceMappingURL=valueFromCron.d.ts.map

package/types/src/resolvers/valueFromCron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromCron.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromCron.js"],"names":[],"mappings":"AACA,oCAAkF;AAiNlF,8EAiCC;AAhPD;;;GAGG;AACH,sDAyMC"}

package/types/src/resolvers/valueFromEnv.d.ts

@@ -0,0 +1,8 @@
+declare const envRefSyntax: RegExp;
+declare function getValueFromEnv(variableString: any): Promise<string | NodeJS.ProcessEnv>;
+export declare let type: string;
+export declare let source: string;
+export declare let syntax: string;
+export declare let description: string;
+export { envRefSyntax as match, getValueFromEnv as resolver };
+//# sourceMappingURL=valueFromEnv.d.ts.map

package/types/src/resolvers/valueFromEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromEnv.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEnv.js"],"names":[],"mappings":"AACA,mCAAqC;AAErC,2FAmBC"}

package/types/src/resolvers/valueFromEval.d.ts

@@ -0,0 +1,7 @@
+declare const evalRefSyntax: RegExp;
+declare function getValueFromEval(variableString: any): Promise<any>;
+export declare let type: string;
+export declare let source: string;
+export declare let description: string;
+export { evalRefSyntax as match, getValueFromEval as resolver };
+//# sourceMappingURL=valueFromEval.d.ts.map

package/types/src/resolvers/valueFromEval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromEval.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEval.js"],"names":[],"mappings":"AACA,oCAA+C;AAE/C,qEA2BC"}

package/types/src/resolvers/valueFromFile.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Resolves a value from a file reference
+ * @param {object} ctx - Context object with instance properties
+ * @param {string} ctx.configPath - Base path for file resolution
+ * @param {Array} ctx.fileRefsFound - Mutable array tracking file refs
+ * @param {RegExp} ctx.variableSyntax - Regex for variable syntax
+ * @param {object} ctx.variablesKnownTypes - Known variable types
+ * @param {object} ctx.variableTypes - Variable types
+ * @param {object} ctx.opts - Options object
+ * @param {object} ctx.originalConfig - Original config
+ * @param {object} ctx.config - Current config
+ * @param {Function} ctx.getDeeperValue - Method for nested lookups
+ * @param {RegExp} ctx.fileRefSyntax - Regex for file() syntax
+ * @param {RegExp} ctx.textRefSyntax - Regex for text() syntax
+ * @param {string} variableString - The variable string to resolve
+ * @param {object} options - Resolution options
+ * @returns {Promise<any>}
+ */
+export function getValueFromFile(ctx: {
+    configPath: string;
+    fileRefsFound: any[];
+    variableSyntax: RegExp;
+    variablesKnownTypes: object;
+    variableTypes: object;
+    opts: object;
+    originalConfig: object;
+    config: object;
+    getDeeperValue: Function;
+    fileRefSyntax: RegExp;
+    textRefSyntax: RegExp;
+}, variableString: string, options: object): Promise<any>;
+/**
+ * Parse file contents based on file extension
+ * @param {string} content - Raw file contents
+ * @param {string} filePath - File path (used to determine extension)
+ * @returns {*} Parsed content
+ */
+export function parseFileContents(content: string, filePath: string): any;
+/**
+ * Parses variable string to extract module reference path
+ * Supports both : and . as separators for module references
+ * @param {string} variableString - The full variable string
+ * @param {string} matchedFileString - The matched file path portion
+ * @returns {{ variableArray: string[], moduleName: string|null }}
+ */
+export function parseModuleReference(variableString: string, matchedFileString: string): {
+    variableArray: string[];
+    moduleName: string | null;
+};
+/**
+ * Extracts deep properties from variable string after file match
+ * @param {string} variableString - The full variable string
+ * @param {string} matchedFileString - The matched file path portion
+ * @param {boolean} [includeFirstProperty=false] - Include first property (for default exports)
+ * @returns {string[]} Array of property keys to traverse
+ */
+export function extractDeepProperties(variableString: string, matchedFileString: string, includeFirstProperty?: boolean): string[];
+//# sourceMappingURL=valueFromFile.d.ts.map

package/types/src/resolvers/valueFromFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CA8SxB;AAxVD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAkUD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}

package/types/src/resolvers/valueFromGit.d.ts

@@ -0,0 +1,11 @@
+declare function _exports(cwd: any): {
+    type: string;
+    source: string;
+    prefix: string;
+    syntax: string;
+    description: string;
+    match: RegExp;
+    resolver: (variableString: any) => Promise<any>;
+};
+export = _exports;
+//# sourceMappingURL=valueFromGit.d.ts.map

package/types/src/resolvers/valueFromGit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromGit.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromGit.js"],"names":[],"mappings":"AAiViB;;;;;;;;EAUhB"}

package/types/src/resolvers/valueFromNumber.d.ts

@@ -0,0 +1,6 @@
+declare function isNumberVariable(variableString: any): any;
+declare function getValueFromNumber(variableString: any): Promise<number>;
+export declare let type: string;
+export declare let internal: boolean;
+export { isNumberVariable as match, getValueFromNumber as resolver };
+//# sourceMappingURL=valueFromNumber.d.ts.map

package/types/src/resolvers/valueFromNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromNumber.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromNumber.js"],"names":[],"mappings":"AAEA,4DAGC;AAED,0EAEC"}

package/types/src/resolvers/valueFromOptions.d.ts

@@ -0,0 +1,9 @@
+declare const optRefSyntax: RegExp;
+declare function getValueFromOptions(variableString: any, options: any): Promise<any>;
+export declare let type: string;
+export declare let source: string;
+export declare let prefix: string;
+export declare let syntax: string;
+export declare let description: string;
+export { optRefSyntax as match, getValueFromOptions as resolver };
+//# sourceMappingURL=valueFromOptions.d.ts.map

package/types/src/resolvers/valueFromOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromOptions.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromOptions.js"],"names":[],"mappings":"AACA,mCAAqC;AAErC,sFASC"}

package/types/src/resolvers/valueFromSelf.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=valueFromSelf.d.ts.map

package/types/src/resolvers/valueFromSelf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromSelf.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromSelf.js"],"names":[],"mappings":""}

package/types/src/resolvers/valueFromString.d.ts

@@ -0,0 +1,6 @@
+declare const stringRefSyntax: RegExp;
+declare function getValueFromString(variableString: any): Promise<string>;
+export declare let type: string;
+export declare let internal: boolean;
+export { stringRefSyntax as match, getValueFromString as resolver };
+//# sourceMappingURL=valueFromString.d.ts.map

package/types/src/resolvers/valueFromString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromString.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromString.js"],"names":[],"mappings":"AAEA,sCAAiD;AAEjD,0EAGC"}

package/types/src/sync.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(variableSources?: any[]): (args: any) => Promise<any>;
+export = _exports;
+//# sourceMappingURL=sync.d.ts.map

package/types/src/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/sync.js"],"names":[],"mappings":"AASiB,qDAgCD,SAAI,kBAwCnB"}

package/types/src/utils/PromiseTracker.d.ts

@@ -0,0 +1,19 @@
+export = PromiseTracker;
+declare class PromiseTracker {
+    reset(): void;
+    promiseList: any[];
+    promiseMap: {};
+    startTime: number;
+    cursor: number;
+    start(): void;
+    interval: NodeJS.Timeout;
+    report(): void;
+    stop(): void;
+    add(variable: any, promise: any, specifier: any, hasFilter: any, promiseKey: any): any;
+    contains(variable: any): boolean;
+    get(variable: any, specifier: any): any;
+    getPending(): any[];
+    getSettled(): any[];
+    getAll(): any[];
+}
+//# sourceMappingURL=PromiseTracker.d.ts.map

package/types/src/utils/PromiseTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseTracker.d.ts","sourceRoot":"","sources":["../../../src/utils/PromiseTracker.js"],"names":[],"mappings":";AAGA;IAIE,cAKC;IAJC,mBAAqB;IACrB,eAAoB;IACpB,kBAA2B;IAC3B,eAAe;IAEjB,cAGC;IADC,yBAAyD;IAE3D,eAqBC;IACD,aAGC;IACD,uFA+BC;IACD,iCAEC;IACD,wCAIC;IACD,oBAEC;IACD,oBAEC;IACD,gBAEC;CACF"}

package/types/src/utils/encoders/index.d.ts

@@ -0,0 +1,2 @@
+export function decodeEncodedValue(value: any): any;
+//# sourceMappingURL=index.d.ts.map