Use interface instead of type for all Base types

library/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to the library will be documented in this file.
 
 ## vX.X.X (Month DD, YYYY)
 
+- Add `Default` and `DefaultAsync` type and refactor codebase
+- Add `Fallback` and `FallbackAsync` type and refactor codebase
+- Refactor `getDefaults` and `getDefaultsAsync` method (pull request #259)
+- Refactor `getFallbacks` and `getFallbacksAsync` method (pull request #259)
 - Remove deprecated properties of `safeParse` and `safeParseAsync` method
 - Fix `NestedPath` type of `flatten` for async schemas (issue #456)
 

library/src/methods/fallback/fallback.ts

@@ -3,16 +3,19 @@ import { schemaResult } from '../../utils/index.ts';
 import { getFallback } from '../getFallback/index.ts';
 import type { FallbackInfo } from './types.ts';
 
-// TODO: Should we create a Fallback and Default type to simplify the generics?
+/**
+ * Fallback type.
+ */
+export type Fallback<TSchema extends BaseSchema> =
+  | Output<TSchema>
+  | ((info?: FallbackInfo) => Output<TSchema>);
 
 /**
  * Schema with fallback type.
  */
 export type SchemaWithFallback<
   TSchema extends BaseSchema = BaseSchema,
-  TFallback extends
-    | Output<TSchema>
-    | ((info?: FallbackInfo) => Output<TSchema>) = Output<TSchema>,
+  TFallback extends Fallback<TSchema> = Fallback<TSchema>,
 > = TSchema & {
   /**
    * The fallback value.
@@ -30,8 +33,7 @@ export type SchemaWithFallback<
  */
 export function fallback<
   TSchema extends BaseSchema,
-  const TFallback extends // TODO: Should we also allow `undefined`
-    Output<TSchema> | ((info?: FallbackInfo) => Output<TSchema>),
+  const TFallback extends Fallback<TSchema>, // TODO: Should we also allow `undefined`
 >(
   schema: TSchema,
   fallback: TFallback

library/src/methods/fallback/fallbackAsync.ts

@@ -3,16 +3,19 @@ import { schemaResult } from '../../utils/index.ts';
 import { getFallbackAsync } from '../getFallback/index.ts';
 import type { FallbackInfo } from './types.ts';
 
+/**
+ * Fallback async type.
+ */
+export type FallbackAsync<TSchema extends BaseSchemaAsync> =
+  | Output<TSchema>
+  | ((info?: FallbackInfo) => Output<TSchema> | Promise<Output<TSchema>>);
+
 /**
  * Schema with fallback async type.
  */
 export type SchemaWithFallbackAsync<
   TSchema extends BaseSchemaAsync = BaseSchemaAsync,
-  TFallback extends
-    | Output<TSchema>
-    | ((
-        info?: FallbackInfo
-      ) => Output<TSchema> | Promise<Output<TSchema>>) = Output<TSchema>,
+  TFallback extends FallbackAsync<TSchema> = FallbackAsync<TSchema>,
 > = TSchema & {
   /**
    * The fallback value.
@@ -30,9 +33,7 @@ export type SchemaWithFallbackAsync<
  */
 export function fallbackAsync<
   TSchema extends BaseSchemaAsync,
-  const TFallback extends
-    | Output<TSchema>
-    | ((info?: FallbackInfo) => Output<TSchema> | Promise<Output<TSchema>>),
+  const TFallback extends FallbackAsync<TSchema>,
 >(
   schema: TSchema,
   fallback: TFallback

library/src/methods/getDefault/getDefault.ts

@@ -1,16 +1,18 @@
-import type { BaseSchema, Output } from '../../types/index.ts';
+import type { BaseSchema, Default } from '../../types/index.ts';
 import type { DefaultValue } from './types.ts';
 
 /**
  * Schema with maybe default type.
  */
-export type SchemaWithMaybeDefault<TSchema extends BaseSchema = BaseSchema> =
-  TSchema & {
-    /**
-     * The optional default value.
-     */
-    default?: Output<TSchema> | (() => Output<TSchema> | undefined);
-  };
+export type SchemaWithMaybeDefault<
+  TSchema extends BaseSchema = BaseSchema,
+  TDefault extends Default<TSchema> = Default<TSchema>,
+> = TSchema & {
+  /**
+   * The optional default value.
+   */
+  default?: TDefault;
+};
 
 /**
  * Returns the default value of the schema.

library/src/methods/getDefault/getDefaultAsync.ts

@@ -1,4 +1,4 @@
-import type { BaseSchemaAsync, Output } from '../../types/index.ts';
+import type { BaseSchemaAsync, DefaultAsync } from '../../types/index.ts';
 import type { SchemaWithMaybeDefault } from './getDefault.ts';
 import type { DefaultValue } from './types.ts';
 
@@ -7,16 +7,12 @@ import type { DefaultValue } from './types.ts';
  */
 export type SchemaWithMaybeDefaultAsync<
   TSchema extends BaseSchemaAsync = BaseSchemaAsync,
+  TDefault extends DefaultAsync<TSchema> = DefaultAsync<TSchema>,
 > = TSchema & {
   /**
    * The optional default value.
    */
-  default?:
-    | Output<TSchema>
-    | (() =>
-        | Output<TSchema>
-        | Promise<Output<TSchema> | undefined>
-        | undefined);
+  default?: TDefault;
 };
 
 /**

library/src/methods/getDefault/types.ts

@@ -1,4 +1,4 @@
-import type { Output } from '../../types/index.ts';
+import type { Input } from '../../types/index.ts';
 import type { SchemaWithMaybeDefault } from './getDefault.ts';
 import type { SchemaWithMaybeDefaultAsync } from './getDefaultAsync.ts';
 
@@ -7,10 +7,10 @@ import type { SchemaWithMaybeDefaultAsync } from './getDefaultAsync.ts';
  */
 export type DefaultValue<
   TSchema extends SchemaWithMaybeDefault | SchemaWithMaybeDefaultAsync,
-> = TSchema['default'] extends Output<TSchema> | undefined
+> = TSchema['default'] extends Input<TSchema> | undefined
   ? TSchema['default']
-  : TSchema['default'] extends () => Output<TSchema> | undefined
+  : TSchema['default'] extends () => Input<TSchema> | undefined
     ? ReturnType<TSchema['default']>
-    : TSchema['default'] extends () => Promise<Output<TSchema> | undefined>
+    : TSchema['default'] extends () => Promise<Input<TSchema> | undefined>
       ? Awaited<ReturnType<TSchema['default']>>
       : undefined;

library/src/methods/getDefaults/getDefaults.ts

@@ -4,7 +4,8 @@ import type {
   TupleItems,
   TupleSchema,
 } from '../../schemas/index.ts';
-import type { BaseSchema } from '../../types/index.ts';
+import type { BaseSchema } from '../../types/schema.ts';
+import { hasType } from '../../utils/index.ts';
 import {
   getDefault,
   type SchemaWithMaybeDefault,
@@ -26,32 +27,27 @@ export function getDefaults<
   TSchema extends SchemaWithMaybeDefault<
     BaseSchema | ObjectSchema<ObjectEntries, any> | TupleSchema<TupleItems, any>
   >,
->(schema: TSchema): DefaultValues<TSchema> {
-  // Create defaults variable
-  let defaults: any;
-
-  // If schema contains a default function, set its default value
+>(schema: TSchema): DefaultValues<TSchema> | undefined {
+  // If schema has default, return its value
   if (schema.default !== undefined) {
-    defaults = getDefault(schema);
+    return getDefault(schema);
+  }
 
-    // Otherwise, check if schema is of kind object or tuple
-  } else if ('type' in schema) {
-    // If it is an object schema, set object with default value of each entry
-    if (schema.type === 'object') {
-      defaults = {};
-      for (const key in schema.entries) {
-        defaults[key] = getDefaults(schema.entries[key]);
-      }
+  // If it is an object schema, return default of each entry
+  if (hasType(schema, 'object')) {
+    return Object.fromEntries(
+      Object.entries(schema.entries).map(([key, value]) => [
+        key,
+        getDefaults(value),
+      ])
+    ) as DefaultValues<TSchema>;
+  }
 
-      // If it is a tuple schema, set array with default value of each item
-    } else if (schema.type === 'tuple') {
-      defaults = [];
-      for (let key = 0; key < schema.items.length; key++) {
-        defaults.push(getDefaults(schema.items[key]));
-      }
-    }
+  // If it is a tuple schema, return default of each item
+  if (hasType(schema, 'tuple')) {
+    return schema.items.map(getDefaults) as DefaultValues<TSchema>;
   }
 
-  // Return default values
-  return defaults;
+  // Otherwise, return undefined
+  return undefined;
 }

library/src/methods/getDefaults/getDefaultsAsync.ts

@@ -8,7 +8,8 @@ import type {
   TupleSchema,
   TupleSchemaAsync,
 } from '../../schemas/index.ts';
-import type { BaseSchema, BaseSchemaAsync } from '../../types/index.ts';
+import type { BaseSchema, BaseSchemaAsync } from '../../types/schema.ts';
+import { hasType } from '../../utils/index.ts';
 import {
   getDefaultAsync,
   type SchemaWithMaybeDefault,
@@ -39,32 +40,31 @@ export async function getDefaultsAsync<
         | ObjectSchemaAsync<ObjectEntriesAsync, any>
         | TupleSchemaAsync<TupleItemsAsync, any>
       >,
->(schema: TSchema): Promise<DefaultValues<TSchema>> {
-  // Create defaults variable
-  let defaults: any;
-
-  // If schema contains a default function, set its default value
+>(schema: TSchema): Promise<DefaultValues<TSchema> | undefined> {
+  // If schema contains default, return its value
   if (schema.default !== undefined) {
-    defaults = await getDefaultAsync(schema);
+    return getDefaultAsync(schema);
+  }
 
-    // Otherwise, check if schema is of kind object or tuple
-  } else if ('type' in schema) {
-    // If it is an object schema, set object with default value of each entry
-    if (schema.type === 'object') {
-      defaults = {};
-      for (const key in schema.entries) {
-        defaults[key] = await getDefaultsAsync(schema.entries[key]);
-      }
+  // If it is an object schema, return default of each entry
+  if (hasType(schema, 'object')) {
+    return Object.fromEntries(
+      await Promise.all(
+        Object.entries(schema.entries).map(async ([key, value]) => [
+          key,
+          await getDefaultsAsync(value),
+        ])
+      )
+    ) as DefaultValues<TSchema>;
+  }
 
-      // If it is a tuple schema, set array with default value of each item
-    } else if (schema.type === 'tuple') {
-      defaults = [];
-      for (let key = 0; key < schema.items.length; key++) {
-        defaults.push(await getDefaultsAsync(schema.items[key]));
-      }
-    }
+  // If it is a tuple schema, return default of each item
+  if (hasType(schema, 'tuple')) {
+    return Promise.all(
+      schema.items.map(getDefaultsAsync)
+    ) as DefaultValues<TSchema>;
   }
 
-  // Return default values
-  return defaults;
+  // Otherwise, return undefined
+  return undefined;
 }

library/src/methods/getFallback/getFallback.ts

@@ -1,17 +1,20 @@
-import type { BaseSchema, Output } from '../../types/index.ts';
+import type { BaseSchema } from '../../types/index.ts';
+import type { Fallback } from '../fallback/index.ts';
 import type { FallbackInfo } from '../fallback/types.ts';
 import type { FallbackValue } from './types.ts';
 
 /**
  * Schema with maybe fallback type.
  */
-export type SchemaWithMaybeFallback<TSchema extends BaseSchema = BaseSchema> =
-  TSchema & {
-    /**
-     * The optional fallback value.
-     */
-    fallback?: Output<TSchema> | ((info?: FallbackInfo) => Output<TSchema>);
-  };
+export type SchemaWithMaybeFallback<
+  TSchema extends BaseSchema = BaseSchema,
+  TFallback extends Fallback<TSchema> = Fallback<TSchema>,
+> = TSchema & {
+  /**
+   * The optional fallback value.
+   */
+  fallback?: TFallback;
+};
 
 /**
  * Returns the fallback value of the schema.

library/src/methods/getFallback/getFallbackAsync.ts

@@ -1,4 +1,5 @@
-import type { BaseSchemaAsync, Output } from '../../types/index.ts';
+import type { BaseSchemaAsync } from '../../types/index.ts';
+import type { FallbackAsync } from '../fallback/index.ts';
 import type { FallbackInfo } from '../fallback/types.ts';
 import type { SchemaWithMaybeFallback } from './getFallback.ts';
 import type { FallbackValue } from './types.ts';
@@ -8,13 +9,12 @@ import type { FallbackValue } from './types.ts';
  */
 export type SchemaWithMaybeFallbackAsync<
   TSchema extends BaseSchemaAsync = BaseSchemaAsync,
+  TFallback extends FallbackAsync<TSchema> = FallbackAsync<TSchema>,
 > = TSchema & {
   /**
    * The optional fallback value.
    */
-  fallback?:
-    | Output<TSchema>
-    | ((info?: FallbackInfo) => Output<TSchema> | Promise<Output<TSchema>>);
+  fallback?: TFallback;
 };
 
 /**

library/src/methods/getFallbacks/getFallbacks.ts

@@ -4,7 +4,8 @@ import type {
   TupleItems,
   TupleSchema,
 } from '../../schemas/index.ts';
-import type { BaseSchema } from '../../types/index.ts';
+import type { BaseSchema } from '../../types/schema.ts';
+import { hasType } from '../../utils/index.ts';
 import {
   getFallback,
   type SchemaWithMaybeFallback,
@@ -26,32 +27,27 @@ export function getFallbacks<
   TSchema extends SchemaWithMaybeFallback<
     BaseSchema | ObjectSchema<ObjectEntries, any> | TupleSchema<TupleItems, any>
   >,
->(schema: TSchema): FallbackValues<TSchema> {
-  // Create fallbacks variable
-  let fallbacks: any;
-
-  // If schema has a fallback, set its value
+>(schema: TSchema): FallbackValues<TSchema> | undefined {
+  // If schema has fallback, return its value
   if (schema.fallback !== undefined) {
-    fallbacks = getFallback(schema);
+    return getFallback(schema);
+  }
 
-    // Otherwise, check if schema is of kind object or tuple
-  } else if ('type' in schema) {
-    // If it is an object schema, set object with fallback value of each entry
-    if (schema.type === 'object') {
-      fallbacks = {};
-      for (const key in schema.entries) {
-        fallbacks[key] = getFallbacks(schema.entries[key]);
-      }
+  // If it is an object schema, return fallback of each entry
+  if (hasType(schema, 'object')) {
+    return Object.fromEntries(
+      Object.entries(schema.entries).map(([key, value]) => [
+        key,
+        getFallbacks(value),
+      ])
+    ) as FallbackValues<TSchema>;
+  }
 
-      // If it is a tuple schema, set array with fallback value of each item
-    } else if (schema.type === 'tuple') {
-      fallbacks = [];
-      for (let key = 0; key < schema.items.length; key++) {
-        fallbacks.push(getFallbacks(schema.items[key]));
-      }
-    }
+  // If it is a tuple schema, return fallback of each item
+  if (hasType(schema, 'tuple')) {
+    return schema.items.map(getFallbacks) as FallbackValues<TSchema>;
   }
 
-  // Return fallback values
-  return fallbacks;
+  // Otherwise, return undefined
+  return undefined;
 }