feat: shorthand functions

shigma · shigma · commit 8e9347b7e750 · 2025-09-01T21:05:42.000+08:00
diff --git a/packages/core/src/core.ts b/packages/core/src/core.ts
@@ -1,9 +1,8 @@
 import { StandardSchemaV1 } from '@standard-schema/spec'
 
 const kSchema = Symbol.for('schemastery')
-const kValidationError = Symbol.for('ValidationError')
 
-export interface ParseOptions {
+export interface ValidateOptions {
   autofix?: boolean
   ignore?: (data: any, schema: Schema) => boolean
   path?: PropertyKey[]
@@ -38,7 +37,7 @@ export abstract class Schema<S = any, T extends S = S> implements StandardSchema
     },
   }
 
-  abstract validate(value: unknown, options: ParseOptions): Schema.Result<T>
+  abstract validate(value: unknown, options: ValidateOptions): Schema.Result<T>
 
   format(): string {
     return this.type
@@ -61,30 +60,3 @@ export abstract class Schema<S = any, T extends S = S> implements StandardSchema
 Object.defineProperty(Schema.prototype, kSchema, {
   value: true,
 })
-
-export class ValidationError extends TypeError {
-  name = 'ValidationError'
-
-  constructor(message: string, public options: ParseOptions) {
-    let prefix = '$'
-    for (const segment of options.path || []) {
-      if (typeof segment === 'string') {
-        prefix += '.' + segment
-      } else if (typeof segment === 'number') {
-        prefix += '[' + segment + ']'
-      } else if (typeof segment === 'symbol') {
-        prefix += `[Symbol(${segment.toString()})]`
-      }
-    }
-    if (prefix.startsWith('.')) prefix = prefix.slice(1)
-    super((prefix === '$' ? '' : `${prefix} `) + message)
-  }
-
-  static is(error: any): error is ValidationError {
-    return !!error?.[kValidationError]
-  }
-}
-
-Object.defineProperty(ValidationError.prototype, kValidationError, {
-  value: true,
-})
diff --git a/packages/core/src/schema/any.ts b/packages/core/src/schema/any.ts
@@ -1,11 +1,17 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Any {}
+namespace $Any {}
 
-export class $Any<T> extends Schema<T> {
+class $Any<T> extends Schema<T> {
   type = 'any'
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     return { value: value as T }
   }
 }
+
+export { $Any as Any }
+
+export function any<T = any>() {
+  return new $Any<T>()
+}
diff --git a/packages/core/src/schema/array.ts b/packages/core/src/schema/array.ts
@@ -1,15 +1,15 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
 const isArray = (value: unknown): value is readonly unknown[] => Array.isArray(value)
 
-export namespace $Array {
+namespace $Array {
   export interface Options<S, T extends S = S> {
     inner: Schema<S, T>
     length?: Schema<number>
   }
 }
 
-export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
+class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
   type = 'array'
   options: $Array.Options<S, T>
 
@@ -27,7 +27,7 @@ export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
     return `Array<${this.options.inner.format()}>`
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (!isArray(value)) return this.failure(value, options.path)
     if (this.options.length) {
       const result = this.options.length.validate(value.length, options)
@@ -52,3 +52,9 @@ export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
     return { value: values }
   }
 }
+
+export { $Array as Array }
+
+export function array<S, T extends S = S>(inner: Schema<S, T>) {
+  return new $Array(inner)
+}
diff --git a/packages/core/src/schema/boolean.ts b/packages/core/src/schema/boolean.ts
@@ -1,10 +1,16 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export class $Boolean extends Schema<boolean> {
+class $Boolean extends Schema<boolean> {
   type = 'boolean'
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (typeof value !== 'boolean') return this.failure(value, options.path)
     return { value }
   }
 }
+
+export { $Boolean as Boolean }
+
+export function boolean() {
+  return new $Boolean()
+}
diff --git a/packages/core/src/schema/const.ts b/packages/core/src/schema/const.ts
@@ -1,13 +1,13 @@
 import { deepEqual } from 'cosmokit'
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Const {
+namespace $Const {
   export interface Options<T> {
     value: T
   }
 }
 
-export class $Const<T> extends Schema<T> {
+class $Const<T> extends Schema<T> {
   type = 'const'
   options: $Const.Options<T>
 
@@ -22,10 +22,16 @@ export class $Const<T> extends Schema<T> {
       : String(this.options.value)
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (!deepEqual(value, this.options.value, true)) {
       return this.failure(value, options.path)
     }
     return { value: value as T }
   }
 }
+
+function $const<T>(value: T) {
+  return new $Const(value)
+}
+
+export { $Const as Const, $const as const }
diff --git a/packages/core/src/schema/dict.ts b/packages/core/src/schema/dict.ts
@@ -1,13 +1,13 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Dict {
+namespace $Dict {
   export interface Options<S, T extends S = S> {
     inner: Schema<S, T>
     key?: Schema<string>
   }
 }
 
-export class $Dict<S, T extends S = S> extends Schema<Readonly<Record<string, S>>, Record<string, T>> {
+class $Dict<S, T extends S = S> extends Schema<Readonly<Record<string, S>>, Record<string, T>> {
   type = 'dict'
   options: $Dict.Options<S, T>
 
@@ -25,7 +25,7 @@ export class $Dict<S, T extends S = S> extends Schema<Readonly<Record<string, S>
     return `Record<${this.options.key ? this.options.key.format() : 'string'}, ${this.options.inner.format()}>`
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
       return this.failure(value, options.path)
     }
@@ -52,3 +52,9 @@ export class $Dict<S, T extends S = S> extends Schema<Readonly<Record<string, S>
     return { value: values }
   }
 }
+
+export { $Dict as Dict }
+
+export function dict<S, T extends S = S>(inner: Schema<S, T>) {
+  return new $Dict(inner)
+}
diff --git a/packages/core/src/schema/function.ts b/packages/core/src/schema/function.ts
@@ -1,10 +1,16 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export class $Function extends Schema<Function> {
+class $Function extends Schema<Function> {
   type = 'function'
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (typeof value !== 'function') return this.failure(value, options.path)
     return { value }
   }
 }
+
+function $function() {
+  return new $Function()
+}
+
+export { $Function as Function, $function as function }
diff --git a/packages/core/src/schema/intersect.ts b/packages/core/src/schema/intersect.ts
@@ -39,3 +39,7 @@ class $Intersect<S, T extends S = S> extends Schema<S, T> {
 }
 
 export { $Intersect as Intersect }
+
+export function intersect(items: Schema[]) {
+  return new $Intersect(items)
+}
diff --git a/packages/core/src/schema/is.ts b/packages/core/src/schema/is.ts
@@ -1,13 +1,13 @@
 import { isNullable } from 'cosmokit'
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Is {
+namespace $Is {
   export interface Options {
     constructor: { name: string }
   }
 }
 
-export class $Is<T> extends Schema<T> {
+class $Is<T> extends Schema<T> {
   type = 'is'
   options: $Is.Options
 
@@ -20,7 +20,7 @@ export class $Is<T> extends Schema<T> {
     return this.options.constructor.name
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     let isValid: boolean
     if (typeof this.options.constructor === 'function') {
       isValid = value instanceof this.options.constructor
@@ -42,3 +42,9 @@ export class $Is<T> extends Schema<T> {
     return { value: value as T }
   }
 }
+
+export { $Is as Is }
+
+export function is<T>(constructor: { new (...args: any[]): T } | { name: string }) {
+  return new $Is<T>(constructor)
+}
diff --git a/packages/core/src/schema/never.ts b/packages/core/src/schema/never.ts
@@ -1,11 +1,17 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Never {}
+namespace $Never {}
 
-export class $Never<T> extends Schema<T> {
+class $Never extends Schema<never> {
   type = 'never'
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     return this.failure(value, options.path)
   }
 }
+
+export { $Never as Never }
+
+export function never() {
+  return new $Never()
+}
diff --git a/packages/core/src/schema/number.ts b/packages/core/src/schema/number.ts
@@ -1,4 +1,4 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
 function decimalShift(data: number, digits: number) {
   const str = data.toString()
@@ -21,15 +21,15 @@ function isMultipleOf(data: number, min: number, step: number) {
   return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0
 }
 
-export namespace $Number {
+namespace $Number {
   export interface Options {
     max?: number
     min?: number
     step?: number
   }
 }
 
-export class $Number extends Schema<number> {
+class $Number extends Schema<number> {
   type = 'number'
   options: $Number.Options = {}
 
@@ -48,7 +48,7 @@ export class $Number extends Schema<number> {
     return this
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (typeof value !== 'number') return this.failure(value, options.path)
     const { max = Infinity, min = -Infinity } = this.options
     if (value > max) return this.failure(value, options.path, ` greater than ${max}`)
@@ -60,3 +60,9 @@ export class $Number extends Schema<number> {
     return { value }
   }
 }
+
+export { $Number as Number }
+
+export function number() {
+  return new $Number()
+}
diff --git a/packages/core/src/schema/object.ts b/packages/core/src/schema/object.ts
@@ -1,13 +1,13 @@
-import { ParseOptions, Schema } from '../core.ts'
+import { ValidateOptions, Schema } from '../core.ts'
 
-export namespace $Object {
+namespace $Object {
   export interface Options {
     items: Record<string, Schema>
     extra?: Schema // TODO
   }
 }
 
-export class $Object<S, T extends S = S> extends Schema<S, T> {
+class $Object<S, T extends S = S> extends Schema<S, T> {
   type = 'object'
   options: $Object.Options
 
@@ -26,7 +26,7 @@ export class $Object<S, T extends S = S> extends Schema<S, T> {
     return `{ ${defs.join(', ')} }`
   }
 
-  validate(value: unknown, options: ParseOptions) {
+  validate(value: unknown, options: ValidateOptions) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
       return this.failure(value, options.path)
     }
@@ -49,3 +49,9 @@ export class $Object<S, T extends S = S> extends Schema<S, T> {
     return { value: target }
   }
 }
+
+export { $Object as Object }
+
+export function object<S, T extends S = S>(items: Record<string, Schema<S, T>>) {
+  return new $Object(items)
+}
diff --git a/packages/core/src/schema/string.ts b/packages/core/src/schema/string.ts
diff --git a/packages/core/src/schema/transform.ts b/packages/core/src/schema/transform.ts
diff --git a/packages/core/src/schema/tuple.ts b/packages/core/src/schema/tuple.ts
diff --git a/packages/core/src/schema/union.ts b/packages/core/src/schema/union.ts

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`import { deepEqual } from 'cosmokit'`
`2`		`-import { ParseOptions, Schema } from '../core.ts'`
	`2`	`+import { ValidateOptions, Schema } from '../core.ts'`
`3`	`3`
`4`		`-export namespace $Const {`
	`4`	`+namespace $Const {`
`5`	`5`	`export interface Options<T> {`
`6`	`6`	`value: T`
`7`	`7`	`}`
`8`	`8`	`}`
`9`	`9`
`10`		`-export class $Const<T> extends Schema<T> {`
	`10`	`+class $Const<T> extends Schema<T> {`
`11`	`11`	`type = 'const'`
`12`	`12`	`options: $Const.Options<T>`
`13`	`13`
`@@ -22,10 +22,16 @@ export class $Const<T> extends Schema<T> {`
`22`	`22`	`: String(this.options.value)`
`23`	`23`	`}`
`24`	`24`
`25`		`- validate(value: unknown, options: ParseOptions) {`
	`25`	`+ validate(value: unknown, options: ValidateOptions) {`
`26`	`26`	`if (!deepEqual(value, this.options.value, true)) {`
`27`	`27`	`return this.failure(value, options.path)`
`28`	`28`	`}`
`29`	`29`	`return { value: value as T }`
`30`	`30`	`}`
`31`	`31`	`}`
	`32`	`+`
	`33`	`+function $const<T>(value: T) {`
	`34`	`+ return new $Const(value)`
	`35`	`+}`
	`36`	`+`
	`37`	`+export { $Const as Const, $const as const }`
Original file line number	Diff line number	Diff line change
`@@ -39,3 +39,7 @@ class $Intersect<S, T extends S = S> extends Schema<S, T> {`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`export { $Intersect as Intersect }`
	`42`	`+`
	`43`	`+export function intersect(items: Schema[]) {`
	`44`	`+ return new $Intersect(items)`
	`45`	`+}`