zcb 0.3.3 → 0.3.5

package/src/createConfigBuilder.ts

@@ -1,8 +1,6 @@
-import { type JSONSchema7 } from 'json-schema';
 import { cloneDeep, merge } from 'lodash-es';
 import { v4 as uuidV4 } from 'uuid';
-import { type ZodError, type z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ZodError, z } from 'zod';
 import { cloneNonEnumerableValues } from './transformers/cloneNonEnumerableValues.ts';
 import { collateDefaultValues } from './utils/collateDefaultValues.ts';
 import { isDerivedValueCallback } from './utils/isDerivedValueCallback.ts';
@@ -10,7 +8,6 @@ import { isInvalidPropertyOverride } from './utils/isInvalidPropertyOverride.ts'
 import { RESERVED_KEYWORDS, isPropertyReservedWord } from './utils/isPropertyReservedWord.ts';
 import { isSchemaValid } from './utils/isSchemaValid.ts';
 import { isValidValue } from './utils/isValidValue.ts';
-import { jsonStringifyReplacer } from './utils/jsonStringifyReplacer.ts';
 import { transformConfigSync } from './utils/transformConfig.ts';
 
 export type ConfigBuilder<ZodTypes> = {
@@ -20,7 +17,7 @@ export type ConfigBuilder<ZodTypes> = {
   ) => ConfigBuilder<ZodTypes>;
 } & {
   $disable: () => ConfigBuilder<ZodTypes>;
-  $errors: () => ZodError['errors'];
+  $errors: () => ZodError['issues'];
   $experiment: (key: string) => ConfigBuilder<ZodTypes>;
   $extend: (configBuilder: ConfigBuilder<ZodTypes>) => ConfigBuilder<ZodTypes>;
   $flush: () => ZodTypes;
@@ -38,7 +35,7 @@ export type CreateConfigBuilderOptions = {
 };
 
 export const createConfigBuilder = <ZodTypes>(
-  zodSchema: z.ZodSchema,
+  zodSchema: z.ZodType,
   options: CreateConfigBuilderOptions = {},
   derivedValueCallbacks: Partial<
     Record<
@@ -58,9 +55,7 @@ export const createConfigBuilder = <ZodTypes>(
 
   type DerivedValueCallback<K extends keyof Config = keyof Config> = (c: Config) => Config[K];
 
-  // Added to simplify type returned from zodToJsonSchema.
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const jsonSchema = zodToJsonSchema(zodSchema) as JSONSchema7;
+  const jsonSchema = z.toJSONSchema(zodSchema);
 
   if (isSchemaValid(jsonSchema)) {
     throw new Error(`The root type of a config schema must be "object", but received "${String(jsonSchema.type)}"`);
@@ -68,29 +63,31 @@ export const createConfigBuilder = <ZodTypes>(
 
   const uuid = options.overrides?.uuid ?? uuidV4;
 
-  const addNonEnumeralBaseProperties = (conf: Config) => {
-    Object.defineProperty(conf, '__zcb', {
-      configurable: false,
-      enumerable: false,
-      value: true,
-    });
-
-    Object.defineProperty(conf, '__id', {
-      configurable: false,
-      enumerable: false,
-      value: uuid(),
-    });
-
-    if (options.type) {
-      Object.defineProperty(conf, '__type', {
+  const addNonEnumeralBaseProperties = (conf: Config): void => {
+    Object.defineProperties(conf, {
+      __id: {
         configurable: false,
         enumerable: false,
-        value: options.type,
-      });
-    }
+        value: uuid(),
+      },
+      __zcb: {
+        configurable: false,
+        enumerable: false,
+        value: true,
+      },
+      ...(options.type
+        ? {
+            __type: {
+              configurable: false,
+              enumerable: false,
+              value: options.type,
+            },
+          }
+        : undefined),
+    });
   };
 
-  const createInitialConfig = () => {
+  const createInitialConfig = (): Config => {
     // Not casting here as loads of downstream impacts that make
     // subsequent typing really difficult.
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -102,7 +99,7 @@ export const createConfigBuilder = <ZodTypes>(
   let config = createInitialConfig();
   let callbacks: Partial<Record<keyof Config, DerivedValueCallback>> = { ...derivedValueCallbacks };
 
-  // Aimed at making it easier for Typescript to derive type.
+  // Aimed at making it easier for TypeScript to derive type.
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const configBuilder = {
     $disable: () => {
@@ -119,9 +116,7 @@ export const createConfigBuilder = <ZodTypes>(
         zodSchema.parse(configBuilder.$values());
         return [];
       } catch (error: unknown) {
-        // This will always be an instance of ZodError.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return (error as ZodError).errors;
+        return error instanceof ZodError ? error.issues : [];
       }
     },
     $experiment: (key: string) => {
@@ -136,7 +131,7 @@ export const createConfigBuilder = <ZodTypes>(
     $extend: (builder: ConfigBuilder<Config>) => {
       config = transformConfigSync<Config>(builder.$values(), [cloneNonEnumerableValues]);
       // @ts-expect-error private property
-      // As __callbacks is private property, Typescript doesn't know what type is.
+      // As __callbacks is private property, TypeScript doesn't know what type is.
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       callbacks = { ...builder.__callbacks } as Partial<Record<keyof Config, DerivedValueCallback>>;
     },
@@ -146,7 +141,7 @@ export const createConfigBuilder = <ZodTypes>(
       return values;
     },
     $fork: () => createConfigBuilder<Config>(zodSchema, options, derivedValueCallbacks, initialValues),
-    $toJson: () => JSON.stringify(configBuilder.$values(), jsonStringifyReplacer, 2),
+    $toJson: () => JSON.stringify(configBuilder.$values(), undefined, 2),
     $validate: () => {
       try {
         zodSchema.parse(configBuilder.$values());
@@ -157,13 +152,15 @@ export const createConfigBuilder = <ZodTypes>(
       }
     },
     $values: () => {
-      for (const property in callbacks) {
-        const callback = callbacks[property];
+      for (const propertyName in callbacks) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const castPropertyName = propertyName as keyof Config;
+        // eslint-disable-next-line unicorn/no-unsafe-property-key
+        const callback = callbacks[castPropertyName];
 
         if (callback) {
-          // Typescript not inferring property is key of Config.
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          config[property as keyof Config] = callback(config);
+          // eslint-disable-next-line unicorn/no-unsafe-property-key
+          config[castPropertyName] = callback(config);
         }
       }
 
@@ -190,7 +187,12 @@ export const createConfigBuilder = <ZodTypes>(
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const castPropertyName = propertyName as keyof Config;
 
-    // Aimed at making it easier for Typescript to derive type.
+    if (!jsonSchema.required?.includes(propertyName) && !Object.hasOwn(config, propertyName)) {
+      // @ts-expect-error Optional properties we want to exist in the config with undefined initial values.
+      config[propertyName] = undefined;
+    }
+
+    // Aimed at making it easier for TypeScript to derive type.
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     configBuilder[castPropertyName] = ((value: Config[keyof Config] | DerivedValueCallback, override?: boolean) => {
       if (isInvalidPropertyOverride(config[castPropertyName], override)) {
@@ -201,7 +203,6 @@ export const createConfigBuilder = <ZodTypes>(
         );
       }
 
-      let propertyValue: Config[keyof Config];
       const MAX_DEPTH = 1;
 
       if (!isValidValue(value)) {
@@ -212,6 +213,8 @@ export const createConfigBuilder = <ZodTypes>(
         );
       }
 
+      let propertyValue: Config[keyof Config];
+
       if (isDerivedValueCallback<DerivedValueCallback>(value)) {
         callbacks[castPropertyName] = value;
         propertyValue = value(config);

package/src/createConfigParser.ts

@@ -5,7 +5,7 @@ import { transformConfig } from './utils/transformConfig.ts';
 export const createConfigParser = async <Config extends object>(
   config: Config,
   { experimentsCallback }: ConfigParserOptions = {},
-) => {
+): Promise<Config> => {
   const handlers: TransformConfigHandler[] = [];
 
   if (experimentsCallback) {

package/src/createConfigReader.ts

@@ -9,7 +9,7 @@ export interface ConfigReader<Config extends object> {
 }
 
 export const createConfigReader = <Config extends object>(config: Config): ConfigReader<Config> => {
-  // Aimed at reducing the amount of work for typescript to resolve type.
+  // Aimed at reducing the amount of work for TypeScript to resolve type.
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return {
     read: <P extends Path<Config>>(path: P, variables?: Record<string, string | number>) => {
@@ -32,7 +32,7 @@ export const createConfigReader = <Config extends object>(config: Config): Confi
       }
 
       return Object.keys(variables).reduce<string>((acc, key) => {
-        return acc.replace(new RegExp(`{{${key}}}`), String(variables[key]));
+        return acc.replace(new RegExp(`{{${key}}}`), () => String(variables[key]));
       }, output);
     },
     scope: <S extends Scope<Config>>(scope: S) => {

package/src/templates/config.ts.hbs

@@ -1,4 +1,4 @@
-/* eslint-disable prettier/prettier, import-x/no-default-export, unicorn/numeric-separators-style, unicorn/no-null */
+/* eslint-disable import-x/no-default-export, unicorn/numeric-separators-style, unicorn/no-null */
 /* This file is autogenerated, do not edit directly, your changes will not perist. */
 
 export default {{{ config }}} as const;

package/src/transformers/cloneNonEnumerableValues.ts

@@ -10,7 +10,7 @@ export const cloneNonEnumerableValues: TransformConfigHandlerSync = <
   config: Config2,
 ) => {
   for (const nonEnumerableKey of NON_ENUMERABLE_KEYS) {
-    if (nonEnumerableKey in config) {
+    if (Object.hasOwn(config, nonEnumerableKey)) {
       Object.defineProperty(clone, nonEnumerableKey, {
         configurable: false,
         enumerable: false,

package/src/transformers/runExperiments.ts

@@ -1,16 +1,27 @@
-import { type AnyRecord, type Buckets, type RunExperimentsCallback, type TransformConfigHandler } from '../types.ts';
+import {
+  type AnyRecord,
+  type Buckets,
+  type RunExperimentsCallback,
+  type TransformConfigHandler,
+  type TransformConfigHandlerReturnType,
+} from '../types.ts';
 
 export const runExperiments =
   (callback: RunExperimentsCallback): TransformConfigHandler =>
-  async <Config extends AnyRecord>(clone: Config, config: Config) => {
+  async <Config extends AnyRecord>(
+    clone: Config,
+    config: Config,
+  ): Promise<TransformConfigHandlerReturnType<Config>> => {
     if ('__experiment' in config && typeof config.__experiment === 'object') {
-      // As __experiment is private property, Typescript doesn't know what type is.
+      // As __experiment is private property, TypeScript doesn't know what type is.
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const { buckets, id } = config.__experiment as { buckets: Buckets<Config>; id: string };
       const bucket = await callback(id);
 
-      if (bucket && bucket in buckets && buckets[bucket]) {
-        return buckets[bucket];
+      if (Object.hasOwn(buckets, bucket)) {
+        // The check above essentially makes sure the value cannot be null
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return buckets[bucket]!;
       }
     }
 

package/src/utils/arrayHasInvalidDefaults.ts

@@ -1,6 +1,6 @@
-import { type JSONSchema7 } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 
-export const arrayHasInvalidDefaults = (propertyDefinition: JSONSchema7) => {
+export const arrayHasInvalidDefaults = (propertyDefinition: JSONSchema.JSONSchema): boolean => {
   const { items } = propertyDefinition;
-  return items && typeof items === 'object' && 'default' in items;
+  return !!items && typeof items === 'object' && 'default' in items;
 };

package/src/utils/collateDefaultValues.ts

@@ -1,11 +1,11 @@
-import { type JSONSchema7 } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 import { arrayHasInvalidDefaults } from './arrayHasInvalidDefaults.ts';
 import { collateObjectPropertyDefaults } from './collateObjectPropertyDefaults.ts';
 import { RESERVED_KEYWORDS, isPropertyReservedWord } from './isPropertyReservedWord.ts';
 import { isValidPropertyDefinition } from './isValidPropertyDefinition.ts';
 import { recordHasInvalidDefaults } from './recordHasInvalidDefaults.ts';
 
-export const collateDefaultValues = <Config>(jsonSchema: JSONSchema7) => {
+export const collateDefaultValues = <Config>(jsonSchema: JSONSchema.JSONSchema): Partial<Config> => {
   const defaultValues: Partial<Config> = {};
 
   for (const propertyName in jsonSchema.properties) {
@@ -17,14 +17,14 @@ export const collateDefaultValues = <Config>(jsonSchema: JSONSchema7) => {
       );
     }
 
-    // Typescript not inferring property is key of Config.
+    // 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.
+        // 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];
       }
@@ -49,7 +49,7 @@ export const collateDefaultValues = <Config>(jsonSchema: JSONSchema7) => {
         const propertyDefaults = collateObjectPropertyDefaults(propertyDefinition);
 
         if (propertyDefaults) {
-          // Typescript not inferring propertyDefaults is Config value.
+          // 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/collateObjectPropertyDefaults.ts

@@ -1,9 +1,11 @@
-import { type JSONSchema7 } from 'json-schema';
 import { isBoolean, isUndefined } from 'lodash-es';
 import { type Jsonifiable } from 'type-fest';
+import { type JSONSchema } from 'zod/v4/core';
 import { objectPropertyHasDefaults } from './objectPropertyHasDefaults.ts';
 
-export const collateObjectPropertyDefaults = (propertyDefinition: JSONSchema7) => {
+export const collateObjectPropertyDefaults = (
+  propertyDefinition: JSONSchema.JSONSchema,
+): Record<string, Jsonifiable> | undefined => {
   const { properties } = propertyDefinition;
 
   if (!properties || !objectPropertyHasDefaults(propertyDefinition)) {

package/src/utils/importValidateTransformWriteConfig.ts

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
 import shelljs from 'shelljs';
-import { type Commands } from '../cli.ts';
+import { type CliCommands } from '../cli.ts';
 import { type ConfigBuilder } from '../createConfigBuilder.ts';
 import { type SetupExperimentsCallback } from '../types.ts';
 import { transformWriteConfig } from './transformWriteConfig.ts';
@@ -8,10 +8,12 @@ import { transformWriteConfig } from './transformWriteConfig.ts';
 export const importValidateTransformWriteConfig = (
   inputFile: string,
   outputFile: string,
-  command: Commands,
+  command: CliCommands,
   experimentCallbackFile?: string,
-) => {
+): void => {
   import(resolve(process.cwd(), inputFile))
+    // TODO: Will revisit
+    // eslint-disable-next-line unicorn/prefer-await
     .then(({ default: configBuilder }: { default: ConfigBuilder<object> }) => {
       if (!configBuilder.$validate()) {
         shelljs.echo(`zcd ${command} => invalid config`);
@@ -25,16 +27,22 @@ export const importValidateTransformWriteConfig = (
 
       if (experimentCallbackFile) {
         import(resolve(process.cwd(), experimentCallbackFile))
+          // TODO: Will revisit
+          // eslint-disable-next-line unicorn/prefer-await
           .then(({ default: experimentsCallback }: { default: SetupExperimentsCallback }) => {
             void transformWriteConfig(configBuilder.$values(), { experimentsCallback, outputFile });
           })
+          // TODO: Will revisit
+          // eslint-disable-next-line unicorn/prefer-await
           .catch((error: unknown) => {
-            if (error instanceof Error) {
-              shelljs.echo(`zcd ${command} => error message: ${error.message}`);
+            if (!(error instanceof Error)) {
+              return;
+            }
+
+            shelljs.echo(`zcd ${command} => error message: ${error.message}`);
 
-              if (error.stack) {
-                shelljs.echo(`zcd ${command} => error stack:\n${error.stack}\n`);
-              }
+            if (error.stack) {
+              shelljs.echo(`zcd ${command} => error stack:\n${error.stack}\n`);
             }
           });
 
@@ -43,13 +51,17 @@ export const importValidateTransformWriteConfig = (
 
       void transformWriteConfig(configBuilder.$values(), { outputFile });
     })
+    // TODO: Will revisit
+    // eslint-disable-next-line unicorn/prefer-await
     .catch((error: unknown) => {
-      if (error instanceof Error) {
-        shelljs.echo(`zcd ${command} => error message: ${error.message}`);
+      if (!(error instanceof Error)) {
+        return;
+      }
+
+      shelljs.echo(`zcd ${command} => error message: ${error.message}`);
 
-        if (error.stack) {
-          shelljs.echo(`zcd ${command} => error stack:\n${error.stack}\n`);
-        }
+      if (error.stack) {
+        shelljs.echo(`zcd ${command} => error stack:\n${error.stack}\n`);
       }
     });
 };

package/src/utils/isInvalidPropertyOverride.ts

@@ -1,3 +1,3 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isInvalidPropertyOverride = (propertyValue: any, override = false) =>
+export const isInvalidPropertyOverride = (propertyValue: any, override = false): boolean =>
   !override && propertyValue !== undefined;

package/src/utils/isPropertyReservedWord.ts

@@ -10,4 +10,4 @@ export const RESERVED_KEYWORDS = new Set([
   '$values',
 ]);
 
-export const isPropertyReservedWord = (propertyName: string) => RESERVED_KEYWORDS.has(propertyName);
+export const isPropertyReservedWord = (propertyName: string): boolean => RESERVED_KEYWORDS.has(propertyName);

package/src/utils/isSchemaValid.ts

@@ -1,3 +1,3 @@
-import { type JSONSchema7 } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 
-export const isSchemaValid = (schema: JSONSchema7) => schema.type !== 'object';
+export const isSchemaValid = (schema: JSONSchema.JSONSchema): boolean => schema.type !== 'object';

package/src/utils/isValidPropertyDefinition.ts

@@ -1,5 +1,5 @@
-import { type JSONSchema7, type JSONSchema7Definition } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 
 export const isValidPropertyDefinition = (
-  propertyDefinition: JSONSchema7Definition | undefined,
-): propertyDefinition is JSONSchema7 => typeof propertyDefinition === 'object';
+  propertyDefinition?: JSONSchema._JSONSchema,
+): propertyDefinition is JSONSchema.JSONSchema => !!propertyDefinition && typeof propertyDefinition === 'object';

package/src/utils/objectPropertyHasDefaults.ts

@@ -1,5 +1,5 @@
-import { type JSONSchema7 } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 
-export const objectPropertyHasDefaults = (propertyDefinition: JSONSchema7) =>
-  propertyDefinition.properties &&
+export const objectPropertyHasDefaults = (propertyDefinition: JSONSchema.JSONSchema): boolean =>
+  !!propertyDefinition.properties &&
   Object.values(propertyDefinition.properties).some(value => typeof value === 'object' && 'default' in value);

package/src/utils/recordHasInvalidDefaults.ts

@@ -1,6 +1,6 @@
-import { type JSONSchema7 } from 'json-schema';
+import { type JSONSchema } from 'zod/v4/core';
 
-export const recordHasInvalidDefaults = (propertyDefinition: JSONSchema7) =>
-  propertyDefinition.additionalProperties &&
+export const recordHasInvalidDefaults = (propertyDefinition: JSONSchema.JSONSchema): boolean =>
+  !!propertyDefinition.additionalProperties &&
   typeof propertyDefinition.additionalProperties === 'object' &&
   'default' in propertyDefinition.additionalProperties;

package/src/utils/transformConfig.test.ts

@@ -17,18 +17,23 @@ describe('transformConfig', () => {
           "locales": [
             "en_GB",
           ],
+          "name": undefined,
           "pages": {
             "contactDetails": {
               "name": "contactDetails",
+              "path": undefined,
+              "queryParams": undefined,
               "sections": [
                 {
                   "name": "header",
+                  "sections": undefined,
                 },
                 {
                   "name": "body",
                   "sections": [
                     {
                       "name": "main",
+                      "sections": undefined,
                     },
                     {
                       "name": "sidebar",
@@ -65,8 +70,10 @@ describe('transformConfig', () => {
           },
           "routes": [
             {
+              "aliases": undefined,
               "page": "personalDetails",
               "path": "personal-details",
+              "routes": undefined,
             },
             {
               "page": "contactDetails",
@@ -100,18 +107,23 @@ describe('transformConfigSync', () => {
           "locales": [
             "en_GB",
           ],
+          "name": undefined,
           "pages": {
             "contactDetails": {
               "name": "contactDetails",
+              "path": undefined,
+              "queryParams": undefined,
               "sections": [
                 {
                   "name": "header",
+                  "sections": undefined,
                 },
                 {
                   "name": "body",
                   "sections": [
                     {
                       "name": "main",
+                      "sections": undefined,
                     },
                     {
                       "name": "sidebar",
@@ -148,8 +160,10 @@ describe('transformConfigSync', () => {
           },
           "routes": [
             {
+              "aliases": undefined,
               "page": "personalDetails",
               "path": "personal-details",
+              "routes": undefined,
             },
             {
               "page": "contactDetails",

package/src/utils/transformConfig.ts

@@ -46,15 +46,21 @@ export const transformConfig = async <Config extends AnyRecord>(
   }
 
   for (const key in config) {
+    // TODO: Need to look at this
+    // eslint-disable-next-line unicorn/no-unsafe-property-key
     const value = config[key];
 
     if (isPlainObject(value)) {
+      // TODO: Need to look at this
+      // eslint-disable-next-line unicorn/no-unsafe-property-key
       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
+      // TODO: Need to look at this
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, unicorn/no-unsafe-property-key
       transform[key] = (await transformArray(value, handler)) as Config[Extract<keyof Config, string>];
     } else {
+      // TODO: Need to look at this
+      // eslint-disable-next-line unicorn/no-unsafe-property-key
       transform[key] = value;
     }
   }
@@ -107,15 +113,21 @@ export const transformConfigSync = <Config extends AnyRecord>(
   }
 
   for (const key in config) {
+    // TODO: Need to look at this
+    // eslint-disable-next-line unicorn/no-unsafe-property-key
     const value = config[key];
 
     if (isPlainObject(value)) {
+      // TODO: Need to look at this
+      // eslint-disable-next-line unicorn/no-unsafe-property-key
       transform[key] = transformConfigSync(value, handler);
     } else if (Array.isArray(value)) {
-      // transformArraySync returns an any type.
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      // TODO: Need to look at this
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, unicorn/no-unsafe-property-key
       transform[key] = transformArraySync(value, handler) as Config[Extract<keyof Config, string>];
     } else {
+      // TODO: Need to look at this
+      // eslint-disable-next-line unicorn/no-unsafe-property-key
       transform[key] = value;
     }
   }