feat: simplify base class hierarchy

docs/extending.md

@@ -49,7 +49,7 @@ Note that `addMethod` isn't magic, it mutates the prototype of the passed in sch
 
 If you're use case calls for creating an entirely new type. inheriting from
 and existing schema class may be best: Generally you should not inheriting from
-the abstract `BaseSchema` unless you know what you are doing. The other types are fair game though.
+the abstract `Schema` unless you know what you are doing. The other types are fair game though.
 
 You should keep in mind some basic guidelines when extending schemas:
 

src/Lazy.ts

@@ -8,7 +8,7 @@ import type {
  SchemaLazyDescription,
 } from './schema';
 import { Flags, ISchema } from './util/types';
-import { BaseSchema } from '.';
+import { Schema } from '.';
 
 export type LazyBuilder<
  T,
@@ -60,8 +60,8 @@ class Lazy<T, TContext = AnyObject, TDefault = any, TFlags extends Flags = any>
  private _resolve = (
  value: any,
  options: ResolveOptions<TContext> = {},
- ): BaseSchema<T, TContext, TDefault, TFlags> => {
- let schema = this.builder(value, options) as BaseSchema<
+ ): Schema<T, TContext, TDefault, TFlags> => {
+ let schema = this.builder(value, options) as Schema<
  T,
  TContext,
  TDefault,

src/array.ts

@@ -22,7 +22,7 @@ import {
  ISchema,
  UnsetFlag,
 } from './util/types';
-import BaseSchema, { SchemaInnerTypeDescription, SchemaSpec } from './schema';
+import Schema, { SchemaInnerTypeDescription, SchemaSpec } from './schema';
 import { ResolveOptions } from './Condition';
 
 export type RejectorFn = (
@@ -43,7 +43,7 @@ export default class ArraySchema<
  TDefault = undefined,
  TFlags extends Flags = '',
  TIn extends any[] | null | undefined = T[] | undefined,
-> extends BaseSchema<TIn, TContext, TDefault, TFlags> {
+> extends Schema<TIn, TContext, TDefault, TFlags> {
  innerType?: ISchema<T, TContext>;
 
  constructor(type?: ISchema<T, TContext>) {
@@ -289,7 +289,7 @@ export default interface ArraySchema<
  TDefault = undefined,
  TFlags extends Flags = '',
  TIn extends any[] | null | undefined = T[] | undefined,
-> extends BaseSchema<TIn, TContext, TDefault, TFlags> {
+> extends Schema<TIn, TContext, TDefault, TFlags> {
  default<D extends Maybe<TIn>>(
  def: Thunk<D>,
  ): ArraySchema<T, TContext, D, ToggleDefault<TFlags, D>, TIn>;

src/boolean.ts

@@ -1,4 +1,4 @@
-import BaseSchema from './schema';
+import Schema from './schema';
 import type { AnyObject, Maybe, Message, Optionals } from './types';
 import type {
  Defined,
@@ -26,7 +26,7 @@ export default class BooleanSchema<
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  constructor() {
  super({
  type: 'boolean',

src/date.ts

@@ -13,7 +13,7 @@ import type {
  ToggleDefault,
  UnsetFlag,
 } from './util/types';
-import BaseSchema from './schema';
+import Schema from './schema';
 
 let invalidDate = new Date('');
 
@@ -34,7 +34,7 @@ export default class DateSchema<
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  static INVALID_DATE = invalidDate;
 
  constructor() {
@@ -113,7 +113,7 @@ export default interface DateSchema<
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  default<D extends Maybe<TType>>(
  def: Thunk<D>,
  ): DateSchema<TType, TContext, D, ToggleDefault<TFlags, D>>;

src/index.ts

@@ -1,7 +1,7 @@
-import Mixed, {
+import MixedSchema, {
  create as mixedCreate,
- MixedSchema,
  MixedOptions,
+ TypeGuard,
 } from './mixed';
 import BooleanSchema, { create as boolCreate } from './boolean';
 import StringSchema, { create as stringCreate } from './string';
@@ -15,7 +15,7 @@ import ValidationError from './ValidationError';
 import reach from './util/reach';
 import isSchema from './util/isSchema';
 import setLocale from './setLocale';
-import BaseSchema, { AnySchema } from './schema';
+import Schema, { AnySchema } from './schema';
 import type { InferType } from './util/types';
 
 function addMethod<T extends AnySchema>(
@@ -48,6 +48,7 @@ export type {
  InferType as Asserts,
  AnySchema,
  MixedOptions,
+ TypeGuard,
 };
 
 export {
@@ -69,9 +70,8 @@ export {
 };
 
 export {
- BaseSchema,
- Mixed as MixedSchema,
- MixedSchema as MixedSchemaClass,
+ Schema,
+ MixedSchema,
  BooleanSchema,
  StringSchema,
  NumberSchema,

src/mixed.ts

@@ -8,14 +8,42 @@ import type {
  ToggleDefault,
  UnsetFlag,
 } from './util/types';
-import BaseSchema from './schema';
+import Schema from './schema';
 
-export declare class MixedSchema<
+const returnsTrue: any = () => true;
+
+export type TypeGuard<TType> = (value: any) => value is NonNullable<TType>;
+export interface MixedOptions<TType> {
+ type?: string;
+ check?: TypeGuard<TType>;
+}
+export function create<TType = any>(
+ spec?: MixedOptions<TType> | TypeGuard<TType>,
+) {
+ return new MixedSchema<TType | undefined>(spec);
+}
+
+export default class MixedSchema<
+ TType = any,
+ TContext = AnyObject,
+ TDefault = undefined,
+ TFlags extends Flags = '',
+> extends Schema<TType, TContext, TDefault, TFlags> {
+ constructor(spec?: MixedOptions<TType> | TypeGuard<TType>) {
+ super(
+ typeof spec === 'function'
+ ? { type: 'mixed', check: spec }
+ : { type: 'mixed', check: returnsTrue as TypeGuard<TType>, ...spec },
+ );
+ }
+}
+
+export default interface MixedSchema<
  TType = any,
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  default<D extends Maybe<TType>>(
  def: Thunk<D>,
  ): MixedSchema<TType, TContext, D, ToggleDefault<TFlags, D>>;
@@ -24,7 +52,7 @@ export declare class MixedSchema<
  schema: MixedSchema<IT, IC, ID, IF>,
  ): MixedSchema<Concat<TType, IT>, TContext & IC, ID, TFlags | IF>;
  concat<IT, IC, ID, IF extends Flags>(
- schema: BaseSchema<IT, IC, ID, IF>,
+ schema: Schema<IT, IC, ID, IF>,
  ): MixedSchema<Concat<TType, IT>, TContext & IC, ID, TFlags | IF>;
  concat(schema: this): this;
 
@@ -52,21 +80,4 @@ export declare class MixedSchema<
  ): MixedSchema<TType, TContext, TDefault, SetFlag<TFlags, 's'>>;
 }
 
-const Mixed: typeof MixedSchema = BaseSchema as any;
-
-export default Mixed;
-
-export type TypeGuard<TType> = (value: any) => value is NonNullable<TType>;
-export interface MixedOptions<TType> {
- type?: string;
- check?: TypeGuard<TType>;
-}
-export function create<TType = any>(
- spec?: MixedOptions<TType> | TypeGuard<TType>,
-) {
- return new Mixed<TType | undefined>(
- typeof spec === 'function' ? { check: spec } : spec,
- );
-}
-// XXX: this is using the Base schema so that `addMethod(mixed)` works as a base class
-create.prototype = Mixed.prototype;
+create.prototype = MixedSchema.prototype;

src/number.ts

@@ -12,7 +12,7 @@ import type {
  ToggleDefault,
  UnsetFlag,
 } from './util/types';
-import BaseSchema from './schema';
+import Schema from './schema';
 
 let isNaN = (value: Maybe<number>) => value != +value!;
 
@@ -30,7 +30,7 @@ export default class NumberSchema<
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  constructor() {
  super({
  type: 'number',
@@ -156,7 +156,7 @@ export default interface NumberSchema<
  TContext = AnyObject,
  TDefault = undefined,
  TFlags extends Flags = '',
-> extends BaseSchema<TType, TContext, TDefault, TFlags> {
+> extends Schema<TType, TContext, TDefault, TFlags> {
  default<D extends Maybe<TType>>(
  def: Thunk<D>,
  ): NumberSchema<TType, TContext, D, ToggleDefault<TFlags, D>>;

src/object.ts

@@ -17,7 +17,7 @@ import { InternalOptions, Callback, Maybe, Message } from './types';
 import ValidationError from './ValidationError';
 import type { Defined, Thunk, NotNull, _ } from './util/types';
 import type Reference from './Reference';
-import BaseSchema, { SchemaObjectDescription, SchemaSpec } from './schema';
+import Schema, { SchemaObjectDescription, SchemaSpec } from './schema';
 import { ResolveOptions } from './Condition';
 import type {
  AnyObject,
@@ -74,7 +74,7 @@ export default interface ObjectSchema<
  // will match object schema regardless of defaults
  TDefault = any,
  TFlags extends Flags = '',
-> extends BaseSchema<MakeKeysOptional<TIn>, TContext, TDefault, TFlags> {
+> extends Schema<MakeKeysOptional<TIn>, TContext, TDefault, TFlags> {
  default<D extends Maybe<AnyObject>>(
  def: Thunk<D>,
  ): ObjectSchema<TIn, TContext, D, ToggleDefault<TFlags, 'd'>>;
@@ -105,7 +105,7 @@ export default class ObjectSchema<
  TContext = AnyObject,
  TDefault = any,
  TFlags extends Flags = '',
-> extends BaseSchema<MakeKeysOptional<TIn>, TContext, TDefault, TFlags> {
+> extends Schema<MakeKeysOptional<TIn>, TContext, TDefault, TFlags> {
  fields: Shape<NonNullable<TIn>, TContext> = Object.create(null);
 
  declare spec: ObjectSchemaSpec;
@@ -184,7 +184,7 @@ export default class ObjectSchema<
  parent: intermediateValue,
  });
 
- let fieldSpec = field instanceof BaseSchema ? field.spec : undefined;
+ let fieldSpec = field instanceof Schema ? field.spec : undefined;
  let strict = fieldSpec?.strict;
 
  if (fieldSpec?.strip) {
@@ -391,7 +391,7 @@ export default class ObjectSchema<
  partial() {
  const partial: any = {};
  for (const [key, schema] of Object.entries(this.fields)) {
- partial[key] = schema instanceof BaseSchema ? schema.optional() : schema;
+ partial[key] = schema instanceof Schema ? schema.optional() : schema;
  }
 
  return this.setFields<Partial<TIn>, TDefault>(partial);
@@ -401,9 +401,7 @@ export default class ObjectSchema<
  const partial: any = {};
  for (const [key, schema] of Object.entries(this.fields)) {
  if (schema instanceof ObjectSchema) partial[key] = schema.deepPartial();
- else
- partial[key] =
- schema instanceof BaseSchema ? schema.optional() : schema;
+ else partial[key] = schema instanceof Schema ? schema.optional() : schema;
  }
  return this.setFields<PartialDeep<TIn>, TDefault>(partial);
  }