@atscript/typescript 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import { TAtscriptPlugin } from '@atscript/core';
+
+declare const tsPlugin: () => TAtscriptPlugin;
+
+interface TError {
+    path: string;
+    message: string;
+    details?: TError[];
+}
+interface TValidatorOptions {
+    partial: boolean | 'deep';
+    unknwonProps: 'strip' | 'ignore' | 'error';
+    errorLimit: number;
+}
+declare class Validator {
+    protected readonly def: TAtscriptAnnotatedType;
+    protected opts: TValidatorOptions;
+    constructor(def: TAtscriptAnnotatedType, opts?: Partial<TValidatorOptions>);
+    errors: TError[];
+    protected stackErrors: TError[][];
+    protected stackPath: string[];
+    protected isLimitExceeded(): boolean;
+    protected push(name: string): void;
+    protected pop(saveErrors: boolean): TError[] | undefined;
+    protected clear(): void;
+    protected error(message: string, path?: string, details?: TError[]): void;
+    protected throw(): void;
+    validate(value: any, safe?: boolean): boolean;
+    protected _validate(def: TAtscriptAnnotatedType, value: any): boolean;
+    protected validateUnion(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateIntersection(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateTuple(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateArray(def: TAtscriptAnnotatedType<TAtscriptTypeArray>, value: any): boolean;
+    protected validateObject(def: TAtscriptAnnotatedType<TAtscriptTypeObject>, value: any): boolean;
+    protected validatePrimitive(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: any): boolean;
+    protected validateString(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: string): boolean;
+    protected validateNumber(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: number): boolean;
+}
+declare class ValidatorError extends Error {
+    readonly errors: TError[];
+    name: string;
+    constructor(errors: TError[]);
+}
+
+interface TAtscriptTypeComplex {
+    kind: 'union' | 'intersection' | 'tuple';
+    items: TAtscriptAnnotatedType[];
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeArray {
+    kind: 'array';
+    of: TAtscriptAnnotatedType;
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeObject<K extends string = string> {
+    kind: 'object';
+    props: Map<K, TAtscriptAnnotatedType>;
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeFinal {
+    kind: '';
+    designType: 'string' | 'number' | 'boolean' | 'undefined' | 'null' | 'object' | 'any' | 'never';
+    value?: string | number | boolean;
+    tags: Set<AtscriptPrimitiveTags>;
+}
+type TAtscriptTypeDef = TAtscriptTypeComplex | TAtscriptTypeFinal | TAtscriptTypeArray | TAtscriptTypeObject<string>;
+interface TAtscriptAnnotatedType<T = TAtscriptTypeDef> {
+    __is_anscript_annotated_type: true;
+    type: T;
+    validator: (opts?: TValidatorOptions) => Validator;
+    metadata: TMetadataMap<AtscriptMetadata>;
+    optional?: boolean;
+}
+declare function isAnnotatedType(type: any): type is TAtscriptAnnotatedType;
+type TKind = '' | 'array' | 'object' | 'union' | 'intersection' | 'tuple';
+declare function defineAnnotatedType(_kind?: TKind, base?: any): {
+    $type: any;
+    $def: {
+        kind: TKind;
+    } & Omit<TAtscriptTypeComplex, "kind"> & Omit<TAtscriptTypeFinal, "kind"> & Omit<TAtscriptTypeArray, "kind"> & Omit<TAtscriptTypeObject<string>, "kind">;
+    $metadata: Map<string, unknown>;
+    _existingObject: TAtscriptAnnotatedType | undefined;
+    tags(...tags: string[]): any;
+    designType(value: TAtscriptTypeFinal["designType"]): any;
+    value(value: string | number | boolean): any;
+    of(value: TAtscriptAnnotatedType): any;
+    item(value: TAtscriptAnnotatedType): any;
+    prop(name: string, value: TAtscriptAnnotatedType): any;
+    optional(): any;
+    refTo(type: any, chain?: string[]): any;
+    annotate(key: string, value: any, asArray?: boolean): any;
+};
+interface TMetadataMap<O extends object> extends Map<keyof O, O[keyof O]> {
+    get<K extends keyof O>(key: K): O[K] | undefined;
+    set<K extends keyof O>(key: K, value: O[K]): this;
+}
+
+export { type TAtscriptAnnotatedType, type TAtscriptTypeArray, type TAtscriptTypeComplex, type TAtscriptTypeDef, type TAtscriptTypeFinal, type TAtscriptTypeObject, type TMetadataMap, type TValidatorOptions, Validator, ValidatorError, tsPlugin as default, defineAnnotatedType, isAnnotatedType };