@webergency-utils/typechecker 0.1.9 → 0.2.1

package/dist/index.js

@@ -1,3 +1,22 @@
+const TRANSFORMER_MISSING = 'Typechecker transformer was not applied. Register { "transform": "@webergency-utils/typechecker/transformer" } in tsconfig plugins (requires ts-patch).';
+/** Returns whether `input` already matches `T`. Does not coerce; `from` is ignored. */
+export function is(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+/** Validates and returns the (possibly coerced) value. Use `from` when conversion is needed. */
+export function assert(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+/** Asserts `input` already matches `T`. Does not coerce; `from` is ignored. */
+export function assertGuard(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+export function validate(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+export function jsonSchema() {
+    throw new Error(TRANSFORMER_MISSING);
+}
 export * from './runtime/validators.js';
 export * from './runtime/tags.js';
 export * from './runtime/casing.js';

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+declare function init(modules: {
+    typescript: typeof ts;
+}): {
+    create: (info: ts.server.PluginCreateInfo) => any;
+};
+export default init;

package/dist/plugin.js

@@ -0,0 +1,30 @@
+import { collectStaticConstraintDiagnostics } from './engine/staticAsserts.js';
+function init(modules) {
+    function create(info) {
+        const proxy = Object.create(null);
+        const ls = info.languageService;
+        for (const key of Object.keys(ls)) {
+            proxy[key] = ls[key];
+        }
+        proxy.getSemanticDiagnostics = (fileName) => {
+            const base = ls.getSemanticDiagnostics(fileName);
+            const program = ls.getProgram();
+            if (!program) {
+                return base;
+            }
+            const sourceFile = program.getSourceFile(fileName);
+            if (!sourceFile || sourceFile.isDeclarationFile) {
+                return base;
+            }
+            if (fileName.includes('node_modules')) {
+                return base;
+            }
+            const checker = program.getTypeChecker();
+            const extra = collectStaticConstraintDiagnostics(sourceFile, checker);
+            return [...base, ...extra];
+        };
+        return proxy;
+    }
+    return { create };
+}
+export default init;

package/dist/runtime/casing.d.ts

@@ -12,7 +12,7 @@ type SnakeToPascal<S extends string> = Capitalize<SnakeToCamel<S>>;
 type SnakeToKebab<S extends string> = S extends `${infer L}_${infer R}` ? `${L}-${SnakeToKebab<R>}` : S;
 type SnakeToDot<S extends string> = S extends `${infer L}_${infer R}` ? `${L}.${SnakeToDot<R>}` : S;
 type SnakeToUpperSnake<S extends string> = Uppercase<S>;
-type ReplaceId<S extends string> = S extends `${infer L}Id` ? `${L}ID` : S extends `id` ? `ID` : S extends `Id` ? `ID` : S;
+type ReplaceId<S extends string> = S extends `${infer L}Id` ? `${L}ID` : S extends 'id' ? 'ID' : S extends 'Id' ? 'ID' : S;
 type ToCamelCaseID<S extends string> = ReplaceId<SnakeToCamel<S>>;
 type ToPascalCaseID<S extends string> = ReplaceId<SnakeToPascal<S>>;
 type Leading<S extends string> = S extends `_${infer R}` ? `_${Leading<R>}` : S extends `-${infer R}` ? `-${Leading<R>}` : S extends `.${infer R}` ? `.${Leading<R>}` : S extends `$${infer R}` ? `$${Leading<R>}` : '';
@@ -20,9 +20,9 @@ type Trailing<S extends string> = S extends `${infer L}_` ? `${Trailing<L>}_` :
 type StripLeading<S extends string> = S extends `_${infer R}` ? StripLeading<R> : S extends `-${infer R}` ? StripLeading<R> : S extends `.${infer R}` ? StripLeading<R> : S extends `$${infer R}` ? StripLeading<R> : S;
 type StripTrailing<S extends string> = S extends `${infer L}_` ? StripTrailing<L> : S extends `${infer L}-` ? StripTrailing<L> : S extends `${infer L}.` ? StripTrailing<L> : S extends `${infer L}$` ? StripTrailing<L> : S;
 type FormatCoreCasing<S extends string, Casing extends CasingFormat> = Casing extends 'snake_case' ? Normalized<S> : Casing extends 'SNAKE_CASE' ? SnakeToUpperSnake<Normalized<S>> : Casing extends 'camelCase' ? SnakeToCamel<Normalized<S>> : Casing extends 'PascalCase' ? SnakeToPascal<Normalized<S>> : Casing extends 'kebab-case' ? SnakeToKebab<Normalized<S>> : Casing extends 'dot.case' ? SnakeToDot<Normalized<S>> : Casing extends 'camelCaseID' ? ToCamelCaseID<Normalized<S>> : Casing extends 'PascalCaseID' ? ToPascalCaseID<Normalized<S>> : S;
-export type FormatCasing<S extends string, Casing extends CasingFormat, Options extends ConvertCasingOptions = {}> = Options['preserveEnds'] extends false ? FormatCoreCasing<StripLeading<StripTrailing<S>>, Casing> : `${Leading<S>}${FormatCoreCasing<StripLeading<StripTrailing<S>>, Casing>}${Trailing<S>}`;
+export type FormatCasing<S extends string, Casing extends CasingFormat, Options extends ConvertCasingOptions = Record<never, never>> = Options['preserveEnds'] extends false ? FormatCoreCasing<StripLeading<StripTrailing<S>>, Casing> : `${Leading<S>}${FormatCoreCasing<StripLeading<StripTrailing<S>>, Casing>}${Trailing<S>}`;
 type ExtractArray<T> = T extends any[] ? T : never;
-export type ConvertPropertyCasing<T, Casing extends CasingFormat, Options extends ConvertCasingOptions = {}> = T extends [infer F, ...infer R] ? [ConvertPropertyCasing<F, Casing, Options>, ...ExtractArray<ConvertPropertyCasing<R, Casing, Options>>] : T extends (infer E)[] ? ConvertPropertyCasing<E, Casing, Options>[] : T extends string | number | boolean | symbol | bigint | null | undefined ? T : T extends Date | RegExp | Function | Map<any, any> | Set<any> | Promise<any> ? T : T extends object ? {
+export type ConvertPropertyCasing<T, Casing extends CasingFormat, Options extends ConvertCasingOptions = Record<never, never>> = T extends [infer F, ...infer R] ? [ConvertPropertyCasing<F, Casing, Options>, ...ExtractArray<ConvertPropertyCasing<R, Casing, Options>>] : T extends (infer E)[] ? ConvertPropertyCasing<E, Casing, Options>[] : T extends string | number | boolean | symbol | bigint | null | undefined ? T : T extends Date | RegExp | Function | Map<any, any> | Set<any> | Promise<any> ? T : T extends object ? {
     [K in keyof T as K extends string ? FormatCasing<K, Casing, Options> : K]: ConvertPropertyCasing<T[K], Casing, Options>;
 } : T;
 export declare function convertPropertyCasing<T, C extends CasingFormat>(obj: T, casing: C, options?: ConvertCasingOptions): ConvertPropertyCasing<T, C>;

package/dist/runtime/casing.js

@@ -2,7 +2,7 @@ function normalizeString(str) {
     if (/^[A-Z0-9_]+$/.test(str)) {
         str = str.toLowerCase();
     }
-    str = str.replace(/[-\.]/g, '_');
+    str = str.replace(/[-.]/g, '_');
     str = str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
     return str.replace(/_+/g, '_').replace(/^_|_$/g, '');
 }
@@ -12,7 +12,7 @@ function formatCasing(str, casing, options = {}) {
     let trailing = '';
     let core = str;
     if (preserveEnds) {
-        const match = str.match(/^([_\-\.\$]*)(.*?)([_\-\.\$]*)$/);
+        const match = str.match(/^([_\-.$]*)(.*?)([_\-.$]*)$/);
         if (match) {
             leading = match[1];
             core = match[2];
@@ -20,10 +20,10 @@ function formatCasing(str, casing, options = {}) {
         }
     }
     else {
-        core = str.replace(/^([_\-\.\$]*)/, '').replace(/([_\-\.\$]*)$/, '');
+        core = str.replace(/^([_\-.$]*)/, '').replace(/([_\-.$]*)$/, '');
     }
     const normalized = normalizeString(core);
-    let formatted = '';
+    let formatted;
     if (casing === 'snake_case') {
         formatted = normalized;
     }

package/dist/runtime/tags/format.d.ts

@@ -1,5 +1,6 @@
 import type { Format } from './constraint.js';
 export type Email = Format<'email'>;
+export type IdnEmail = Format<'idn-email'>;
 export type UUID = Format<'uuid'>;
 export type URL = Format<'url'>;
 export type IPv4 = Format<'ipv4'>;
@@ -10,6 +11,12 @@ export type Byte = Format<'byte'>;
 export type Password = Format<'password'>;
 export type Regex = Format<'regex'>;
 export type Hostname = Format<'hostname'>;
+export type IdnHostname = Format<'idn-hostname'>;
+export type URI = Format<'uri'>;
+export type UriReference = Format<'uri-reference'>;
+export type IRI = Format<'iri'>;
+export type IriReference = Format<'iri-reference'>;
+export type UriTemplate = Format<'uri-template'>;
 export type Time = Format<'time'>;
 export type Duration = Format<'duration'>;
 export type ObjectId = Format<'objectId'>;

package/dist/runtime/tags/tag.d.ts

@@ -1,3 +1,3 @@
-export type Default<V extends string | number | boolean | null> = {
+export type Default<V = any> = {
     readonly __default?: V;
 };

package/dist/runtime/tags.d.ts

@@ -47,7 +47,7 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
  * Recursively resolves object properties, removing the optional `?` modifier
  * from any properties that have a `tag.Default` applied.
  */
-export type ResolveDefaults<T> = T extends Date | symbol | string | number | boolean | bigint | null | undefined | Function ? T : T extends Array<infer U> ? Array<ResolveDefaults<U>> : T extends object ? {
+export type ResolveDefaults<T> = T extends Date | RegExp | Promise<any> | Map<any, any> | Set<any> | ArrayBuffer | SharedArrayBuffer | DataView | Buffer | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | symbol | string | number | boolean | bigint | null | undefined | Function ? T : T extends Array<infer U> ? Array<ResolveDefaults<U>> : T extends object ? {
     [K in keyof T as IsAny<T[K]> extends true ? never : '__default' extends keyof NonNullable<T[K]> ? K : never]-?: ResolveDefaults<Exclude<T[K], undefined>>;
 } & {
     [K in keyof T as IsAny<T[K]> extends true ? K : '__default' extends keyof NonNullable<T[K]> ? never : K]: ResolveDefaults<T[K]>;

package/dist/runtime/validators.d.ts

@@ -3,27 +3,48 @@ export interface IValidationError {
     path: string;
     value: any;
     error: string;
+    /** Nested failures (e.g. per-arm errors for a failed union). */
+    issues?: IValidationError[];
 }
+/** Internal expected-type labels for custom `from` callbacks. Not exported from the package. */
+type BaseType = 'string' | 'number' | 'boolean' | 'bigint' | 'function' | 'symbol' | 'never' | 'Date' | 'RegExp' | 'Set' | 'Map' | 'Array' | 'Object' | 'instance' | 'null' | 'undefined' | 'tuple' | 'literal';
+type FromOption = 'json' | 'query' | ((key: string, value: any, type: BaseType) => any);
 export interface ValidationContext {
     success: boolean;
     errors: IValidationError[];
     mode: ValidationMode;
-    tryConvert?: boolean;
+    from?: FromOption;
     wrapArrays?: boolean;
+    mutate?: boolean;
     root?: any;
 }
 export interface ValidationOptions {
     mode?: ValidationMode;
-    tryConvert?: boolean;
+    from?: FromOption;
     wrapArrays?: boolean;
+    /** When true, write validated/coerced values onto the input. Default false: always return new containers. */
+    mutate?: boolean;
     schema?: any;
     errorFactory?: (errors: IValidationError[]) => Error;
 }
+/** Query-style number coercion — shared by `from: 'query'` and `transform.ToNumber`. */
+export declare function coerceQueryNumber(v: any): any;
+/** Query-style boolean coercion — shared by `from: 'query'` and `transform.ToBoolean`. */
+export declare function coerceQueryBoolean(v: any): any;
+/** JSON-wire Date revival (ISO / date-parseable strings only). */
+export declare function coerceJsonDate(v: any): any;
+/** Query-style Date coercion — shared by `from: 'query'` and `transform.ToDate`. */
+export declare function coerceQueryDate(v: any): any;
 export declare const validators: {
+    coerceQueryNumber: typeof coerceQueryNumber;
+    coerceQueryBoolean: typeof coerceQueryBoolean;
+    coerceQueryDate: typeof coerceQueryDate;
+    coerceJsonDate: typeof coerceJsonDate;
     string: (v: any, path: string, ctx: ValidationContext) => any;
     number: (v: any, path: string, ctx: ValidationContext) => any;
     bigint: (v: any, path: string, ctx: ValidationContext) => any;
     boolean: (v: any, path: string, ctx: ValidationContext) => any;
+    function: (v: any, path: string, ctx: ValidationContext) => any;
     date: (v: any, path: string, ctx: ValidationContext) => any;
     regexp: (v: any, path: string, ctx: ValidationContext) => any;
     null: (v: any, path: string, ctx: ValidationContext) => null;
@@ -31,7 +52,10 @@ export declare const validators: {
     literal: (v: any, path: string, ctx: ValidationContext, expected: any) => any;
     array: (v: any, path: string, ctx: ValidationContext, childValidator: Function) => any;
     props: (v: any, data: any, path: string, ctx: ValidationContext, props: [string, boolean, Function][]) => void;
-    object: (v: any, path: string, ctx: ValidationContext, allowedKeys?: string[], expected?: string) => boolean;
+    objectShell: (v: any, ctx: ValidationContext) => any;
+    stripExtras: (data: any, ctx: ValidationContext, allowedKeys?: string[]) => any;
+    additionalProps: (v: any, data: any, path: string, ctx: ValidationContext, knownKeys: string[], childValidator: Function) => void;
+    object: (v: any, path: string, ctx: ValidationContext, allowedKeys?: string[], expected?: string) => any;
     templateLiteral: (v: any, path: string, ctx: ValidationContext, regex: RegExp, expected: string) => any;
     minLength: (v: string, path: string, ctx: ValidationContext, min: number, message?: string) => string;
     maxLength: (v: string, path: string, ctx: ValidationContext, max: number, message?: string) => string;
@@ -41,7 +65,7 @@ export declare const validators: {
     exclusiveMaximum: (v: number | bigint, path: string, ctx: ValidationContext, max: number | bigint, message?: string) => number | bigint;
     multipleOf: (v: number | bigint, path: string, ctx: ValidationContext, n: number | bigint, message?: string) => number | bigint;
     pattern: (v: string, path: string, ctx: ValidationContext, regex: RegExp, expected: string, message?: string) => string;
-    format: (v: string, path: string, ctx: ValidationContext, format: string, message?: string) => string;
+    format: (v: string, path: string, ctx: ValidationContext, format: string, message?: string) => any;
     minItems: (v: any[], path: string, ctx: ValidationContext, min: number, message?: string) => any[];
     maxItems: (v: any[], path: string, ctx: ValidationContext, max: number, message?: string) => any[];
     uniqueItems: (v: any[], path: string, ctx: ValidationContext, message?: string) => any[];
@@ -49,6 +73,9 @@ export declare const validators: {
     union: (v: any, path: string, ctx: ValidationContext, checks: Function[], expected?: string) => any;
     tuple: (v: any, path: string, ctx: ValidationContext, checks: Function[]) => any;
     any: (v: any) => any;
+    never: (v: any, path: string, ctx: ValidationContext) => any;
+    symbol: (v: any, path: string, ctx: ValidationContext) => any;
+    instanceOf: (v: any, path: string, ctx: ValidationContext, typeName: string) => any;
     requires: (v: any, path: string, ctx: ValidationContext, reqs: string[], message?: string) => any;
     record: (v: any, path: string, ctx: ValidationContext, childValidator: Function) => any;
     set: (v: any, path: string, ctx: ValidationContext, childValidator: Function, message?: string) => any;
@@ -65,6 +92,7 @@ export declare class MetadataStoreClass {
     getOrCompileSchema(schema: any): Function;
     is(validator: Function, value: any, options?: ValidationMode | ValidationOptions): boolean;
     assert(validator: Function, value: any, options?: ValidationMode | ValidationOptions): any;
+    assertGuard(validator: Function, value: any, options?: ValidationMode | ValidationOptions): void;
     validate(validator: Function, value: any, options?: ValidationMode | ValidationOptions): {
         success: boolean;
         errors: IValidationError[];
@@ -77,13 +105,9 @@ export declare function groupErrorsByPath(errors: IValidationError[]): Record<st
 }>;
 export declare const MetadataStore: MetadataStoreClass;
 export declare function compileSchema(schema: any): (v: any, path: string, ctx: any) => any;
-export declare function toZodIssues(errors: IValidationError[]): {
-    code: string;
-    path: (string | number)[];
-    message: string;
-    received: any;
-}[];
+export declare function toZodIssues(errors: IValidationError[]): any[];
 export declare class ZodLikeError extends Error {
     issues: any[];
     constructor(errors: IValidationError[]);
 }
+export {};