@james-pre/config 1.0.1 → 1.1.0

package/dist/manager.d.ts

@@ -3,12 +3,13 @@ import type { FlattenKeys, GetByString, PartialRecursive } from 'utilium';
 import * as z from 'zod';
 export type FileType = 'system' | 'user' | 'local';
 /** Information about a loaded config file */
-interface File<Value> {
+interface File<Value, Options extends LoadOptions = LoadOptions> {
     path: string;
     wasIncluded: boolean;
     data: Value;
     type: FileType;
     auto: boolean;
+    options: Partial<Options>;
 }
 /**
  * How a file is being loaded
@@ -23,21 +24,21 @@ export interface LoadOptions {
     /**
      * If enabled, the config file will still be loaded if it does not match the schema.
      */
-    loose?: boolean;
+    loose: boolean;
     /**
      * If enabled, the config file will be skipped if it does not exist.
      */
-    optional?: boolean;
+    optional: boolean;
     /**
      * If enabled, an empty config file will be created when it does not exist.
      * Included files are never created.
      */
-    create?: boolean;
+    create: boolean;
     /**
      * Used to mark files that are included, auto-loaded, etc.
      * @internal
      */
-    [kInit]?: FileLoadInit;
+    [kInit]: FileLoadInit;
 }
 declare const kInit: unique symbol;
 export interface ManagerOptions {
@@ -57,37 +58,45 @@ export interface ManagerOptions {
 /**
  * Manager for configuration files
  */
-export declare class Manager<Shape extends Readonly<Record<string, z.ZodType>>, LoadOpts extends LoadOptions = LoadOptions, out In extends z.input<z.ZodObject<Shape>> = z.input<z.ZodObject<Shape>>, out FileData = z.output<ReturnType<typeof z.deepPartial<z.ZodObject<Shape>>>>> extends EventEmitter<{
-    load: [path: string, config: FileData];
-    post_load: [path: string, config: FileData];
+export declare class Manager<Schema extends z.ZodObject, LoadOpts extends LoadOptions = LoadOptions, out In extends z.input<Schema> = z.input<Schema>, out FileData = z.output<ReturnType<typeof z.deepPartial<Schema>>>> extends EventEmitter<{
+    load: [path: string, config: FileData, options: Partial<LoadOpts>];
+    post_load: [path: string, config: FileData, options: Partial<LoadOpts>];
     load_error: [path: string, stage: 'read' | 'create' | 'parse', error: Error];
     create: [path: string];
     change: [];
     write: [path: string, data: FileData];
     reload: [];
 }> {
+    readonly schema: Schema;
     protected options: ManagerOptions;
-    readonly schema: z.ZodObject<Shape>;
-    readonly fileSchema: ReturnType<typeof z.deepPartial<z.ZodObject<Shape>>>;
-    protected files: Map<string, File<FileData>>;
-    readonly data: z.output<z.ZodObject<Shape>>;
-    constructor(shape: Shape, options?: ManagerOptions);
+    readonly fileSchema: ReturnType<typeof z.deepPartial<Schema>>;
+    protected readonly _files: Map<string, File<FileData, LoadOpts>>;
+    get filePaths(): MapIterator<string>;
+    get files(): IteratorObject<Readonly<File<FileData, LoadOpts>>>;
+    configAt(path: string): Readonly<FileData> | undefined;
+    readonly data: z.output<Schema>;
+    constructor(schema: Schema, options?: ManagerOptions);
+    /**
+     * Narrow the type of this manager's load options
+     */
+    $loadOptions<O extends object>(): Manager<Schema, LoadOpts & O, In, FileData>;
+    $assertLoadOptions<O extends object>(): asserts this is Manager<Schema, LoadOpts & O, In, FileData>;
     /**
      * A fresh config with only the schema's defaults applied.
      */
-    get defaults(): z.output<z.ZodObject<Shape>> & In;
-    get<const K extends string | number = FlattenKeys<z.output<z.ZodObject<Shape>>>>(key: K): GetByString<z.output<z.ZodObject<Shape>>, K>;
-    set<const K extends string | number = FlattenKeys<z.output<z.ZodObject<Shape>>>, V = GetByString<z.output<z.ZodObject<Shape>>, K>>(key: K, value: V): void;
+    get defaults(): z.output<Schema> & In;
+    get<const K extends string | number = FlattenKeys<z.output<Schema>>>(key: K): GetByString<z.output<Schema>, K>;
+    set<const K extends string | number = FlattenKeys<z.output<Schema>>, V = GetByString<z.output<Schema>, K>>(key: K, value: V): void;
     /**
      * Deeply merge `config` into the current config. Arrays are replaced rather than combined.
      */
     merge(config: PartialRecursive<In>): void;
     /** Replace the current config with `config`, applying defaults for anything missing. */
     replace(config: In): void;
-    loadFile(path: string, options: LoadOpts): void;
+    loadFile(path: string, options: Partial<LoadOpts>): void;
     /** Get the entry for `path`, adding one for a file that has not been loaded */
-    protected fileAt(path: string): File<FileData>;
-    protected writeFile(file: File<FileData>): void;
+    protected fileAt(path: string): File<FileData, LoadOpts>;
+    protected writeFile(file: File<FileData, LoadOpts>): void;
     /**
      * Replace the contents of the config file at `path` and write it,
      * then rebuild the current config from the defaults and all loaded files.
@@ -108,7 +117,7 @@ export declare class Manager<Shape extends Readonly<Record<string, z.ZodType>>,
     /**
      * Load the files from `defaultPaths`. Missing files are skipped unless `options` says otherwise.
      */
-    loadDefaults(options: LoadOpts): void;
+    loadDefaults(options?: Partial<LoadOpts>): void;
     /**
      * The file a change of the given type is written to:
      * the most recently loaded file of that type, or the path `loadDefaults` would use for it.
@@ -118,6 +127,6 @@ export declare class Manager<Shape extends Readonly<Record<string, z.ZodType>>,
      * Merge `config` into the current config and save it.
      */
     update(config: PartialRecursive<In>, type?: FileType): void;
-    reloadFiles(options: LoadOpts): void;
+    reloadFiles(options?: Partial<LoadOpts>): void;
 }
 export {};

package/dist/manager.js

@@ -145,18 +145,35 @@ let Manager = (() => {
             __esDecorate(this, null, _get_defaultPaths_decorators, { kind: "getter", name: "defaultPaths", static: false, private: false, access: { has: obj => "defaultPaths" in obj, get: obj => obj.defaultPaths }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        options = __runInitializers(this, _instanceExtraInitializers);
-        schema;
+        schema = __runInitializers(this, _instanceExtraInitializers);
+        options;
         fileSchema;
-        files = new Map();
+        _files = new Map();
+        get filePaths() {
+            return this._files.keys();
+        }
+        get files() {
+            return this._files.values().map(f => structuredClone(f));
+        }
+        configAt(path) {
+            return structuredClone(this._files.get(path)?.data);
+        }
         data;
-        constructor(shape, options = {}) {
+        constructor(schema, options = {}) {
             super({ captureRejections: true });
+            this.schema = schema;
             this.options = options;
-            this.schema = z.object(shape);
-            this.fileSchema = z.deepPartial(stripDefaults(z.object(options.enableIncludes ? { ...shape, include } : shape)));
+            this.fileSchema = z.deepPartial(stripDefaults(z.object(options.enableIncludes ? { ...schema.shape, include } : schema.shape)));
             this.data = this.schema.parse(this.defaults);
         }
+        /**
+         * Narrow the type of this manager's load options
+         */
+        $loadOptions() {
+            this.$assertLoadOptions();
+            return this;
+        }
+        $assertLoadOptions() { }
         /**
          * A fresh config with only the schema's defaults applied.
          */
@@ -184,7 +201,7 @@ let Manager = (() => {
             this.emit('change');
         }
         loadFile(path, options) {
-            if (this.files.has(path))
+            if (this._files.has(path))
                 return;
             let json;
             try {
@@ -220,15 +237,16 @@ let Manager = (() => {
                 this.emit('load_error', path, 'parse', e);
                 file = json;
             }
-            this.files.set(path, {
+            this._files.set(path, {
                 auto: false,
                 wasIncluded: false,
                 type: typeFromPath(path),
                 ...(options[kInit] || {}),
                 data: file,
                 path,
+                options,
             });
-            this.emit('load', path, file);
+            this.emit('load', path, file, options);
             this.merge(file);
             if (canInclude(this.options, file))
                 for (const include of file.include ?? []) {
@@ -239,11 +257,11 @@ let Manager = (() => {
                         [kInit]: { ...options[kInit], wasIncluded: true },
                     });
                 }
-            this.emit('post_load', path, file);
+            this.emit('post_load', path, file, options);
         }
         /** Get the entry for `path`, adding one for a file that has not been loaded */
         fileAt(path) {
-            const existing = this.files.get(path);
+            const existing = this._files.get(path);
             if (existing)
                 return existing;
             const file = {
@@ -252,8 +270,9 @@ let Manager = (() => {
                 type: typeFromPath(path),
                 auto: false,
                 wasIncluded: false,
+                options: {},
             };
-            this.files.set(path, file);
+            this._files.set(path, file);
             return file;
         }
         writeFile(file) {
@@ -270,7 +289,7 @@ let Manager = (() => {
             file.data = this.fileSchema.parse(config);
             this.writeFile(file);
             this.replace(this.defaults);
-            for (const file of this.files.values())
+            for (const file of this._files.values())
                 this.merge(file.data);
         }
         /**
@@ -298,7 +317,7 @@ let Manager = (() => {
         /**
          * Load the files from `defaultPaths`. Missing files are skipped unless `options` says otherwise.
          */
-        loadDefaults(options) {
+        loadDefaults(options = {}) {
             for (const { path, type } of this.defaultPaths) {
                 this.loadFile(path, { optional: true, ...options, [kInit]: { type, auto: true } });
             }
@@ -308,7 +327,7 @@ let Manager = (() => {
          * the most recently loaded file of that type, or the path `loadDefaults` would use for it.
          */
         findPath(type) {
-            const loaded = this.files
+            const loaded = this._files
                 .values()
                 .filter(file => (!type || file.type == type) && !file.wasIncluded)
                 .map(file => file.path)
@@ -326,12 +345,12 @@ let Manager = (() => {
         update(config, type) {
             this.updateFile(this.findPath(type), config);
         }
-        reloadFiles(options) {
-            const files = this.files
+        reloadFiles(options = {}) {
+            const files = this._files
                 .values()
                 .filter(file => !file.wasIncluded)
                 .toArray();
-            this.files.clear();
+            this._files.clear();
             this.replace(this.defaults);
             for (const file of files) {
                 this.loadFile(file.path, { ...options, [kInit]: { type: file.type, auto: file.auto } });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@james-pre/config",
-	"version": "1.0.1",
+	"version": "1.1.0",
 	"description": "Manage configuration files",
 	"funding": {
 		"type": "individual",
@@ -20,8 +20,8 @@
 	"scripts": {
 		"format:check": "prettier --check .",
 		"format": "prettier --write .",
-		"build": "tsc",
-		"lint": "tsc --noEmit && eslint src",
+		"build": "tsc -b",
+		"lint": "tsc -b --noEmit && eslint src",
 		"prepublishOnly": "npx tsc"
 	},
 	"repository": {