zcb 0.2.6 → 0.2.7

package/src/types.ts

@@ -33,17 +33,17 @@ export type Scope<Config extends object> = Join<Paths<Config>, '.'>;
 export type SetupExperimentsCallback = <Config extends AnyRecord>(
   id: string,
   clone: Config,
-  config: Config
+  config: Config,
 ) => Promise<Buckets<Config>>;
 
 export type TransformConfigHandler = <Config extends AnyRecord>(
   clone: Config,
-  config: Config
+  config: Config,
 ) => TransformConfigHandlerReturnType<Config> | Promise<TransformConfigHandlerReturnType<Config>>;
 
 export type TransformConfigHandlerSync = <Config extends AnyRecord>(
   clone: Config,
-  config: Config
+  config: Config,
 ) => TransformConfigHandlerReturnType<Config>;
 
 export enum TransformConfigHandlerAction {
@@ -61,17 +61,21 @@ export interface WriteConfigOptions {
   outputFile: string;
 }
 
-export type Leaves<T, LeafPath extends string[] = []> = T extends string
+export type Leaves<T, LeafPath extends string[] = [], Depth extends number = 0> = T extends string
   ? LeafPath
-  : {
-      [K in keyof T & string]: Leaves<T[K], [...LeafPath, K]>;
-    }[keyof T & string];
+  : Depth extends 15
+    ? LeafPath
+    : {
+        [K in keyof T & string]: Leaves<T[K], [...LeafPath, K], LeafPath['length']>;
+      }[keyof T & string];
 
-export type Paths<T, LeafPath extends string[] = []> = T extends string
+export type Paths<T, LeafPath extends string[] = [], Depth extends number = 0> = T extends string
   ? LeafPath
-  : {
-      [K in keyof T & string]: T[K] extends object ? Paths<T[K], [...LeafPath, K]> : LeafPath;
-    }[keyof T & string];
+  : Depth extends 15
+    ? LeafPath
+    : {
+        [K in keyof T & string]: T[K] extends object ? Paths<T[K], [...LeafPath, K], LeafPath['length']> : LeafPath;
+      }[keyof T & string];
 
 export type LeavesScopeDiffs<T1 extends readonly string[][], T2 extends string[]> = {
   [K1 in keyof T1]: List.Length<List.Intersect<T1[K1], T2, '<-contains'>> extends 1

package/src/utils/collateDefaultValues.ts

@@ -6,30 +6,34 @@ import { isValidPropertyDefinition } from './isValidPropertyDefinition.ts';
 import { recordHasInvalidDefaults } from './recordHasInvalidDefaults.ts';
 
 export const collateDefaultValues = <Config>(jsonSchema: JSONSchema7) => {
-  const defaultValues = {} as Partial<Config>;
+  const defaultValues: Partial<Config> = {};
 
   for (const propertyName in jsonSchema.properties) {
     if (isPropertyReservedWord(propertyName)) {
       throw new Error(
         `"${propertyName}" is a reserved keyword within the config builder. Please use a different property name. The full list of reserved keywords is: ${[
           ...RESERVED_KEYWORDS,
-        ].join(', ')}`
+        ].join(', ')}`,
       );
     }
 
+    // Typescript not inferring property is key of Config.
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const castPropertyName = propertyName as keyof Config;
     const propertyDefinition = jsonSchema.properties[propertyName];
 
     if (isValidPropertyDefinition(propertyDefinition)) {
       if (propertyDefinition.default) {
+        // Typescript not inferring propertyDefinition.default is Config value.
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         defaultValues[castPropertyName] = propertyDefinition.default as Config[keyof Config];
       }
 
       if (propertyDefinition.type === 'array' && arrayHasInvalidDefaults(propertyDefinition)) {
         throw new Error(
           `When setting schema array defaults for the array assigned to "${String(
-            castPropertyName
-          )}", set them on the array and not the item.`
+            castPropertyName,
+          )}", set them on the array and not the item.`,
         );
       }
 
@@ -37,14 +41,16 @@ export const collateDefaultValues = <Config>(jsonSchema: JSONSchema7) => {
         if (recordHasInvalidDefaults(propertyDefinition)) {
           throw new Error(
             `When setting schema property defaults for the value of the record assigned to "${String(
-              castPropertyName
-            )}", set them on the record and not the value.`
+              castPropertyName,
+            )}", set them on the record and not the value.`,
           );
         }
 
         const propertyDefaults = collateObjectPropertyDefaults(propertyDefinition);
 
         if (propertyDefaults) {
+          // Typescript not inferring propertyDefaults is Config value.
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           defaultValues[castPropertyName] = propertyDefaults as Config[keyof Config];
         }
       }

package/src/utils/importValidateTransformWriteConfig.ts

@@ -9,7 +9,7 @@ export const importValidateTransformWriteConfig = (
   inputFile: string,
   outputFile: string,
   command: Commands,
-  experimentCallbackFile?: string
+  experimentCallbackFile?: string,
 ) => {
   import(resolve(process.cwd(), inputFile))
     .then(({ default: configBuilder }: { default: ConfigBuilder<object> }) => {

package/src/utils/isValidPropertyDefinition.ts

@@ -1,5 +1,5 @@
 import { type JSONSchema7, type JSONSchema7Definition } from 'json-schema';
 
 export const isValidPropertyDefinition = (
-  propertyDefinition: JSONSchema7Definition | undefined
+  propertyDefinition: JSONSchema7Definition | undefined,
 ): propertyDefinition is JSONSchema7 => typeof propertyDefinition === 'object';

package/src/utils/isValidValue.ts

@@ -2,6 +2,8 @@ import { isPlainObject } from 'lodash-es';
 
 export const isValidValue = (value: unknown, depth = 0): boolean => {
   if (isPlainObject(value)) {
+    // isPlainObject not a type guard.
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const object = value as Record<string, unknown>;
 
     if (object.__zcb === true) {

package/src/utils/transformConfig.ts

@@ -15,19 +15,20 @@ const transformArray = (list: any[], handler: TransformConfigHandler | Transform
       }
 
       if (Array.isArray(entry)) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return transformArray(entry, handler);
       }
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       return entry;
-    })
+    }),
   );
 
 export const transformConfig = async <Config extends AnyRecord>(
   config: Config,
-  handler: TransformConfigHandler | TransformConfigHandler[] = []
+  handler: TransformConfigHandler | TransformConfigHandler[] = [],
 ): Promise<Config> => {
+  // Typing gets too complicated without casting.
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   let transform = {} as Config;
   const handlers = castArray(handler);
 
@@ -35,6 +36,8 @@ export const transformConfig = async <Config extends AnyRecord>(
     const result = await Promise.resolve(callback(transform, config));
 
     if (result.action === TransformConfigHandlerAction.DELETE_NODE) {
+      // Typing gets too complicated without casting.
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return {} as Config;
     }
 
@@ -53,6 +56,8 @@ export const transformConfig = async <Config extends AnyRecord>(
     if (isPlainObject(value)) {
       transform[key] = await transformConfig(value, handler);
     } else if (Array.isArray(value)) {
+      // transformArraySync returns an any type.
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       transform[key] = (await transformArray(value, handler)) as Config[Extract<keyof Config, string>];
     } else {
       transform[key] = value;
@@ -81,8 +86,10 @@ const transformArraySync = (list: any[], handler: TransformConfigHandlerSync | T
 
 export const transformConfigSync = <Config extends AnyRecord>(
   config: Config,
-  handler: TransformConfigHandlerSync | TransformConfigHandlerSync[] = []
+  handler: TransformConfigHandlerSync | TransformConfigHandlerSync[] = [],
 ): Config => {
+  // Typing gets too complicated without casting.
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   let transform = {} as Config;
   const handlers = castArray(handler);
 
@@ -90,6 +97,8 @@ export const transformConfigSync = <Config extends AnyRecord>(
     const result = callback(transform, config);
 
     if (result.action === TransformConfigHandlerAction.DELETE_NODE) {
+      // Typing gets too complicated without casting.
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return {} as Config;
     }
 
@@ -108,6 +117,8 @@ export const transformConfigSync = <Config extends AnyRecord>(
     if (isPlainObject(value)) {
       transform[key] = transformConfigSync(value, handler);
     } else if (Array.isArray(value)) {
+      // transformArraySync returns an any type.
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       transform[key] = transformArraySync(value, handler) as Config[Extract<keyof Config, string>];
     } else {
       transform[key] = value;

package/src/utils/transformWriteConfig.ts

@@ -11,7 +11,7 @@ import { transformConfig } from './transformConfig.ts';
 
 export const transformWriteConfig = async <Config extends object>(
   config: Config,
-  { experimentsCallback, outputFile }: WriteConfigOptions
+  { experimentsCallback, outputFile }: WriteConfigOptions,
 ) => {
   const handlers: TransformConfigHandler[] = [removeDisabledSlices];
 
@@ -20,12 +20,12 @@ export const transformWriteConfig = async <Config extends object>(
   }
 
   const template = Handlebars.compile(
-    readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), './templates/config.ts.hbs'), { encoding: 'utf8' })
+    readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), './templates/config.ts.hbs'), { encoding: 'utf8' }),
   );
 
   const output = template({ config: JSON.stringify(await transformConfig(config, handlers), undefined, 2) }).replaceAll(
     /"([A-Za-z][\dA-Za-z]+)":/g,
-    '$1:'
+    '$1:',
   );
 
   shelljs.echo(`zcd watch => writing to file: ${outputFile}`);