@meltstudio/config-loader 1.0.4 → 2.0.0

package/dist/index.d.ts

@@ -1,130 +1,181 @@
-type SourceTypes = "file" | "env" | "args" | "default";
+declare class ArrayValueContainer {
+    readonly val: ArrayValue;
+    readonly item: OptionTypes;
+    constructor(item: OptionTypes, val: ArrayValue);
+}
+
+interface EnvFileEntry {
+    value: string;
+    line: number;
+    column: number;
+}
+interface EnvFileResult {
+    entries: Map<string, EnvFileEntry>;
+    filePath: string;
+}
+
+interface ConfigErrorEntry {
+    message: string;
+    path?: string;
+    source?: string;
+    kind?: "required" | "type_conversion" | "invalid_path" | "invalid_state" | "file_validation";
+    line?: number;
+    column?: number;
+}
+declare class ConfigLoadError extends Error {
+    readonly errors: ConfigErrorEntry[];
+    readonly warnings: string[];
+    constructor(errors: ConfigErrorEntry[], warnings: string[]);
+}
+declare class ConfigFileError extends ConfigLoadError {
+    constructor(message: string);
+}
+
+declare class OptionErrors {
+    errors: ConfigErrorEntry[];
+    warnings: string[];
+    clearAll(): void;
+}
+
+type Value = boolean | string | number | object | InvalidValue;
+type DefaultValue = Value | (() => string) | (() => number) | (() => boolean);
+type TypedDefaultValue<T extends OptionKind> = T extends PrimitiveKind ? TypeOfPrimitiveKind<T> | (() => TypeOfPrimitiveKind<T>) : DefaultValue;
+interface Node {
+    [key: string]: OptionBase;
+}
+interface OptionClassParams<T extends OptionKind> {
+    kind: T;
+    required: boolean;
+    env: string | null;
+    cli: boolean;
+    help: string;
+    defaultValue?: TypedDefaultValue<T>;
+}
+declare class OptionBase<T extends OptionKind = OptionKind> {
+    readonly params: OptionClassParams<T>;
+    constructor(params: OptionClassParams<T>);
+    getValue<U>(sourceFile: string | string[], env: {
+        [key: string]: string | undefined;
+    }, args: {
+        [key: string]: string | boolean;
+    }, path: Path, defaultValues?: Partial<U>, objectFromArray?: {
+        value: ConfigFileData;
+        file: string;
+        sourceMap?: {
+            lookup(path: string | string[]): {
+                line: number;
+                column: number;
+            } | undefined;
+        } | null;
+    }, envFileResults?: EnvFileResult[], errors?: OptionErrors): ConfigNode | null;
+    private resolveFromFileData;
+    checkType(val: Value, path: Path, sourceOfVal: string, errors?: OptionErrors): Value;
+    protected findInObject(obj: ConfigFileData, path: Path, errors?: OptionErrors): Value | ArrayValue;
+    buildArrayOption(_val: string[] | ConfigFileData[], _errors?: OptionErrors): ArrayValueContainer | InvalidValue;
+}
+
+type SourceTypes = "file" | "env" | "envFile" | "args" | "default";
 declare class ConfigNode {
     value: Value | ArrayValueContainer;
     path: string;
-    source_type: SourceTypes;
+    sourceType: SourceTypes;
     file: string | null;
-    variable_name: string | null;
-    arg_name: string | null;
-    constructor(value: Value | ArrayValue, path: string, source_type: SourceTypes, file: string | null, variable_name: string | null, arg_name: string | null);
+    variableName: string | null;
+    argName: string | null;
+    line: number | null;
+    column: number | null;
+    constructor(value: Value | ArrayValue, path: string, sourceType: SourceTypes, file: string | null, variableName: string | null, argName: string | null, line?: number | null, column?: number | null);
+}
+
+declare class PrimitiveOption<T extends PrimitiveKind = PrimitiveKind> extends OptionBase<T> {
 }
 
 type NodeTree = {
     [key: string]: NodeTree | ConfigNode;
 };
+type RecursivePartial<T> = {
+    [K in keyof T]?: RecursivePartial<T[K]>;
+};
 type SettingsSources<T> = {
     env: boolean;
     args: boolean;
     files?: string | string[] | false;
     dir?: string | false;
-    defaults?: Partial<T>;
+    envFile?: string | string[] | false;
+    defaults?: RecursivePartial<T>;
+    exitOnError?: boolean;
 };
-type OptionKind = "boolean" | "string" | "number" | "any" | "array" | "object";
+type OptionKind = "boolean" | "string" | "number" | "array" | "object";
+type PrimitiveKind = Extract<OptionKind, "boolean" | "string" | "number">;
+type TypeOfPrimitiveKind<T extends PrimitiveKind> = T extends "boolean" ? boolean : T extends "string" ? string : T extends "number" ? number : never;
+type SchemaValue<T extends OptionBase | Node> = T extends OptionBase ? T extends ArrayOption<OptionTypes> ? SchemaValue<T["item"]>[] : T extends ObjectOption<infer R> ? {
+    [K in keyof R]: SchemaValue<R[K]>;
+} : T extends PrimitiveOption<infer R> ? TypeOfPrimitiveKind<R> : never : T extends Node ? {
+    [K in keyof T]: SchemaValue<T[K]>;
+} : never;
 type Path = Array<string | number>;
 type ConfigFileStructure<T> = {
     [key: string]: string | T | number | boolean | Array<T> | string[];
 };
 interface ConfigFileData extends ConfigFileStructure<ConfigFileData> {
 }
-type ArrayValue = Array<any>;
+type ArrayValue = Array<string | number | boolean | ConfigFileData>;
 declare class InvalidValue {
 }
 
-declare class ArrayValueContainer {
-    readonly val: ArrayValue;
-    readonly item: Node | OptionTypes;
-    constructor(item: Node | OptionTypes, val: ArrayValue);
-}
-
-type Value = boolean | string | number | object | InvalidValue;
-type DefaultValue = Value | (() => string) | (() => number) | (() => boolean);
-type RecursiveNode<T> = {
-    [key: string]: OptionBase | T;
-};
-interface Node extends RecursiveNode<Node> {
-}
-interface OptionClassParams {
-    kind: OptionKind;
+interface ArrayOptionClassParams<T extends OptionTypes> {
     required: boolean;
-    env: string | null;
-    cli: boolean;
-    help: string;
-    defaultValue?: DefaultValue;
+    defaultValue?: SchemaValue<T>[] | (() => SchemaValue<T>[]);
+    item: T;
 }
-declare class OptionBase {
-    readonly params: OptionClassParams;
-    constructor(params: OptionClassParams);
-    getValue<T>(sourceFile: string | string[], env: {
-        [key: string]: string | undefined;
-    }, args: {
-        [key: string]: string | boolean;
-    }, path: Path, defaultValues?: Partial<T>, objectFromArray?: {
-        value: ConfigFileData;
-        file: string;
-    }): ConfigNode | null;
-    protected checkNumberType(val: Value, pathStr: string, sourceOfVal: string): Value;
-    checkType(val: Value, path: Path, sourceOfVal: string): Value;
-    protected findInObject(obj: ConfigFileData, path: Path): Value | ArrayValue;
-    buildArrayOption(_val: string[] | ConfigFileData[]): ArrayValueContainer | InvalidValue;
+declare class ArrayOption<T extends OptionTypes> extends OptionBase<"array"> {
+    item: T;
+    constructor(params: ArrayOptionClassParams<T>);
+    buildArrayOption(val: string[] | ConfigFileData[], errors?: OptionErrors): ArrayValueContainer | InvalidValue;
+    checkType(val: Value, path: Path, sourceOfVal: string, errors?: OptionErrors): Value;
 }
 
-interface ArrayOptionClassParams {
+interface ObjectOptionClassParams<T extends Node> {
     required: boolean;
-    defaultValue?: DefaultValue;
-    item: Node | OptionTypes;
-}
-declare class ArrayOption extends OptionBase {
-    item: Node | OptionTypes;
-    constructor(params: ArrayOptionClassParams);
-    buildArrayOption(val: string[] | ConfigFileData[]): ArrayValueContainer | InvalidValue;
-    checkType(val: Value, path: Path, sourceOfVal: string): Value;
+    item: T;
 }
-
-declare class PrimitiveOption extends OptionBase {
+declare class ObjectOption<T extends Node = Node> extends OptionBase<"object"> {
+    item: T;
+    constructor(params: ObjectOptionClassParams<T>);
 }
 
-type OptionTypes = PrimitiveOption | ArrayOption;
+type OptionTypes = PrimitiveOption | ArrayOption<OptionTypes> | ObjectOption<Node>;
 
-declare class Settings<T> {
+declare class SettingsBuilder<T extends Node> {
     private readonly schema;
-    private readonly sources;
-    private sourceFile;
-    private argsData;
-    private envData;
-    private optionsTree;
-    private defaultData;
-    private program;
-    constructor(schema: Node, sources: SettingsSources<T>);
-    private validateFiles;
-    private load;
-    private traverseOptions;
-    private buildOption;
-    private getValidatedArray;
-    private processArrayWithSchema;
-    private setOption;
-    private addArg;
-    private getValuesFromTree;
-    get(): T;
-    getExtended(): NodeTree;
+    constructor(schema: T);
+    load(sources: SettingsSources<SchemaValue<T>>): SchemaValue<T>;
+    loadExtended(sources: SettingsSources<SchemaValue<T>>): NodeTree;
 }
 
-interface OptionPropsArgs {
+interface OptionPropsArgs<T> {
     required?: boolean;
     env?: string | null;
     cli?: boolean;
-    defaultValue?: DefaultValue;
+    defaultValue?: T | (() => T);
     help?: string;
 }
-interface ArrayOptionPropsArgs {
+interface ArrayOptionPropsArgs<T extends OptionTypes> {
+    required?: boolean;
+    item: T;
+    defaultValue?: SchemaValue<T>[] | (() => SchemaValue<T>[]);
+}
+interface ObjectOptionPropsArgs<T extends Node> {
     required?: boolean;
-    item: Node | OptionTypes;
-    defaultValue?: DefaultValue;
+    item: T;
 }
 declare const option: {
-    string: (opts?: OptionPropsArgs) => PrimitiveOption;
-    number: (opts?: OptionPropsArgs) => PrimitiveOption;
-    bool: (opts?: OptionPropsArgs) => PrimitiveOption;
-    array: (opts: ArrayOptionPropsArgs) => ArrayOption;
+    string: (opts?: OptionPropsArgs<string>) => PrimitiveOption<"string">;
+    number: (opts?: OptionPropsArgs<number>) => PrimitiveOption<"number">;
+    bool: (opts?: OptionPropsArgs<boolean>) => PrimitiveOption<"boolean">;
+    array: <T extends OptionTypes>(opts: ArrayOptionPropsArgs<T>) => ArrayOption<T>;
+    object: <T extends Node>(opts: ObjectOptionPropsArgs<T>) => ObjectOption<T>;
+    schema: <T extends Node>(theSchema: T) => SettingsBuilder<T>;
 };
 
-export { Settings as default, option };
+export { type ConfigErrorEntry, ConfigFileError, ConfigLoadError, option as default };