ts-ref-kit 1.0.1 → 1.0.3

package/README.md

@@ -1,4 +1,4 @@
-# Reflect-Types
+# TS-ref-kit
 
 A TypeScript library for type reflection and validation.
 

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "ts-ref-kit",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Type reflection and validation library for TypeScript",
   "main": "dist/index.js",
   "type": "module",
   "files": [
     "dist/**/*",
+    "types/**/*",
     "LICENSE",
     "README.md"
   ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./types/index.d.ts"
     },
     "./parser": {
       "import": "./dist/parser/index.js",
-      "types": "./dist/parser/index.d.ts"
+      "types": "./types/parser/index.d.ts"
     }
   },
   "scripts": {

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reflect-types';
+export * from './reflect-json';

package/types/parser/index.d.ts

@@ -0,0 +1,3 @@
+export * from './reflect-loader';
+export * from './reflect-parser-plugin';
+export * from './reflect-parser';

package/types/parser/path-match.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 检查文件路径是否匹配 glob 规则
+ * @param filePath 要检查的文件路径（绝对或相对路径）
+ * @param pattern glob 规则，如 `/src/**\/.ts`
+ * @returns 是否匹配
+ */
+export default function isPathMatch(filePath: string, pattern: string | string[]): boolean;

package/types/parser/reflect-loader.d.ts

@@ -0,0 +1,9 @@
+export interface ReflectLoaderOptions {
+    sourcePaths: string | string[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    forEnabledClassOnly?: boolean;
+}
+export declare function reflectLoader(options: ReflectLoaderOptions): {
+    outputAllMetas: () => string;
+    transform: (sourceCode: string, sourceFileName: string) => string;
+};

package/types/parser/reflect-parser-plugin.d.ts

@@ -0,0 +1,7 @@
+import { type Plugin } from 'vite';
+import { ReflectLoaderOptions } from './reflect-loader';
+interface Options extends ReflectLoaderOptions {
+    entry: string;
+}
+export declare function reflectParserPlugin(options: Options): Plugin;
+export {};

package/types/parser/reflect-parser.d.ts

@@ -0,0 +1,74 @@
+type Any = any;
+export interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+    indexElementType?: RawTypeDef;
+}
+export interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+export interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+export interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+type RawTypeDef = string | RawTypeDefinition;
+export interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    indexElementType?: RawTypeDef;
+    literalValue?: Any;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    generics?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+}
+type FilePathRule = string | RegExp | (string | RegExp)[];
+export declare function setupReflectTypes(filePaths: string | string[], exclude?: FilePathRule, distFolder?: string): Promise<void>;
+export declare function updateReflectModules(filePath: string, distFolder: string): Promise<void>;
+export declare function parseSource(filePaths?: string | string[], exclude?: FilePathRule): {
+    classDefinitions: Map<string, RawClassDefinition>;
+    interfaceDefinitions: Map<string, RawInterfaceDefinition>;
+    enumDefinitions: Map<string, RawEnumDefinition>;
+    typeAliasDefinitions: Map<string, RawTypeDef>;
+    constTypeDefinitions: Map<string, RawTypeDef>;
+};
+export {};

package/types/reflect-json/Mappable.d.ts

@@ -0,0 +1,13 @@
+import { type EnableReflect } from '../reflect-types';
+import type { Class, JsonValue } from './types';
+export interface Mappable extends EnableReflect {
+    mapping(map: Mapping<Mappable>): void;
+}
+export type Mapping<T extends Mappable> = {
+    [propName in keyof T]-?: (fieldName?: string | symbol, transform?: {
+        fromJSON?: (jsonValue: JsonValue) => Mappable;
+        toJSON?: (obj: Mappable) => JsonValue;
+    }) => void;
+};
+export declare function registerMappable<T extends Mappable>(mappableClass: Class<T>): void;
+export declare function mapAllProperties<T extends Mappable>(target: T, map: Mapping<T>): void;

package/types/reflect-json/decorate.d.ts

@@ -0,0 +1,18 @@
+import { ReflectPropertyKey } from './reflect-extension';
+import type { Any } from './types';
+export declare function defineDecoratedProperty(metaKey: symbol): PropertyDecorator;
+export declare function callDecoratedMethod<Self extends object>(self: Self, metaKey: symbol, ...args: Any[]): Any | undefined;
+export declare function hasDecoratedMethod<Self extends object>(self: Self, metaKey: symbol): boolean;
+export declare function getDecoratedProperty(target: object, metaKey: symbol): ReflectPropertyKey | undefined;
+export declare function getDecoratedPropertyValue<V>(target: object, metaKey: symbol): V | undefined;
+export declare const PropertyWrapper: IPropertyWrapper;
+type IPropertyWrapper = {
+    getField: (owner: object, property: ReflectPropertyKey, fieldSymbol: symbol) => Any;
+    setField: (owner: object, property: ReflectPropertyKey, newValue: Any, fieldSymbol: symbol) => void;
+} & (<T>({ getter, setter, fieldSymbol }: {
+    getter?: (self: object, property: ReflectPropertyKey) => T;
+    setter?: (self: object, newValue: T, property: ReflectPropertyKey) => void;
+    fieldSymbol: symbol;
+}) => PropertyDecorator);
+export declare function Lazy(creator: (self: object, property: ReflectPropertyKey) => Any): PropertyDecorator;
+export {};

package/types/reflect-json/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Mappable';
+export * from './decorate';
+export * from './json-translation';
+export * from './reflect-extension';
+export * from './types';
+export * from './utils';

package/types/reflect-json/json-translation.d.ts

@@ -0,0 +1,38 @@
+import 'reflect-metadata';
+import { Any, AnyObject, Class, ClassOrInstance, JsonObject, JsonValue } from './types';
+type FromJSON<T> = (jsonValue: JsonValue) => T;
+type ToJSON<T> = (obj: T) => JsonValue;
+type SerializedOptions<T> = {
+    name?: string;
+    class?: Class<T>;
+    fromJSON?: FromJSON<T>;
+    toJSON?: ToJSON<T>;
+};
+export declare function setDefaultIgnored(clazz: Class<Any>, defaultIgnored: boolean): void;
+export declare function registerSerializedProperty(target: AnyObject, propName: string, options: SerializedOptions<Any>): void;
+export declare const SerializedClass: PropertyDecorator;
+export declare function Serialized<T extends object>(options?: SerializedOptions<T>): PropertyDecorator;
+export declare function SerializedName(serializedName: string): PropertyDecorator;
+export declare const IgnoreSerialization: PropertyDecorator;
+/**
+ * serialize an object to json string
+ */
+export declare function serialize<T>(value: T): string;
+export declare function serializeTo<T>(value: T): JsonValue;
+/**
+ * convert an object to data object
+ */
+export declare function serializeToData<T extends object>(object: T): JsonObject | JsonObject[];
+export declare function deserialize<T>(json: string | JsonValue, constructorOrTarget?: ClassOrInstance<T>): T;
+export declare function deserializeArray<T>(json: string | JsonValue[], clazz?: Class<T>): T[];
+export declare function deserializeFrom<T extends AnyObject>(data: JsonObject, target: T): void;
+export declare function getSerializeSettings(clazz: Class<Any>): any;
+export interface JsonValueTransform<T> {
+    fromJson: FromJSON<T>;
+    toJson: ToJSON<T>;
+}
+export declare function registerTransform<T>(clazz: Class<T>, transform: JsonValueTransform<T>): void;
+export declare const itSelf: (some: Any) => any;
+export declare const done: () => any;
+export declare const AfterSerialized: PropertyDecorator;
+export {};

package/types/reflect-json/reflect-extension.d.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+import { Any, AnyConstructorFunction, AnyObject, Optional } from './types';
+export type ReflectPropertyKey = string | symbol;
+export type ReflectType = StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | FunctionConstructor | AnyConstructorFunction;
+declare global {
+    namespace Reflect {
+        function getDesignType<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType>;
+        function getReturnType<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType>;
+        function getParamTypes<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType[]>;
+        function addMetadataList<T extends object>(key: symbol, value: Any, target: T): void;
+        function addMetadataList<T extends object>(key: symbol, value: Any, target: T, property: ReflectPropertyKey): void;
+    }
+}

package/types/reflect-json/types.d.ts

@@ -0,0 +1,15 @@
+export type Any = any;
+export type AnyFunction = (...args: Any[]) => Any;
+export type AnyConstructorFunction = new (...args: Any[]) => Any;
+export type Class<T> = new (...args: Any[]) => T;
+export type ClassOrInstance<T> = T | Class<T>;
+export type Dictionary<T> = {
+    [key: string | symbol]: T;
+};
+export type AnyObject = Dictionary<Any>;
+export type Optional<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type JsonValue = string | number | boolean | null | JsonObject | JsonObject[];
+export type JsonObject = {
+    [propName: string]: JsonValue;
+};

package/types/reflect-json/utils.d.ts

@@ -0,0 +1,9 @@
+import { Any, Class } from "./types";
+export declare function asBoolean(value: unknown): boolean;
+export declare function asString(v: unknown): string;
+export declare function asNumber(v: unknown): number;
+export declare function setAnyValue<T>(target: Any, field: string | number | symbol, value: T): void;
+export declare function getAnyValue<T>(target: Any, field: string | number | symbol): T | undefined;
+export declare function getOrSetValue<T>(target: Any, field: string | number | symbol, defaultWith: () => T): T;
+export declare function isDictionary(value: Any): boolean;
+export declare function createNewInstance<T>(clazz: Class<T>): any;

package/types/reflect-types/ClassDefinition.d.ts

@@ -0,0 +1,26 @@
+import type { RawClassDefinition, TypeDefinition } from './index';
+import { InterfaceDefinition, MethodDefinition, PropertyDefinition } from './index';
+import type { AnyConstructorFunction, Dictionary } from './package';
+export declare class ClassDefinition {
+    readonly name: string;
+    readonly superClassName: string;
+    readonly superClass: ClassDefinition | undefined;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition[];
+    readonly jsClass: AnyConstructorFunction;
+    private readonly _implementationNames;
+    private readonly _implementations?;
+    private _allImplementations?;
+    constructor(def: RawClassDefinition & {
+        jsClass: AnyConstructorFunction;
+    });
+    get allMethods(): Dictionary<MethodDefinition>;
+    get allProperties(): Dictionary<PropertyDefinition>;
+    get implementations(): InterfaceDefinition[];
+    get allImplementations(): InterfaceDefinition[];
+    getProperty(propName: string): PropertyDefinition | undefined;
+    get type(): TypeDefinition;
+    isSubClassOf(typeName: string): boolean;
+    isSuperClassOf(typeName: string): boolean;
+    toString(): string;
+}

package/types/reflect-types/EnumDefinition.d.ts

@@ -0,0 +1,8 @@
+import type { RawEnumDefinition, TypeDefinition } from './reflect-definitions';
+export declare class EnumDefinition {
+    readonly name: string;
+    readonly members: Map<string, TypeDefinition>;
+    constructor(def: RawEnumDefinition);
+    get type(): TypeDefinition;
+    get names(): string[];
+}

package/types/reflect-types/InterfaceDefinition.d.ts

@@ -0,0 +1,16 @@
+import type { RawInterfaceDefinition, TypeDefinition } from './index';
+import { MethodDefinition, PropertyDefinition } from './index';
+export declare class InterfaceDefinition {
+    readonly name: string;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition[];
+    private readonly _implementationNames;
+    private _implementations?;
+    private _allImplementations?;
+    constructor(def: RawInterfaceDefinition);
+    get implementations(): InterfaceDefinition[];
+    get allImplementations(): InterfaceDefinition[];
+    get type(): TypeDefinition;
+    toString(): string;
+    buildBaseObject(): {};
+}

package/types/reflect-types/MethodDefinition.d.ts

@@ -0,0 +1,15 @@
+import { type RawMethodDefinition, type TypeDefinition } from './index';
+export declare class MethodDefinition {
+    name: string;
+    isPrivate: boolean;
+    isStatic: boolean;
+    isAsync: boolean;
+    returnType: TypeDefinition;
+    args: {
+        name: string;
+        type?: TypeDefinition;
+        isOptional: boolean;
+    }[];
+    constructor(def: RawMethodDefinition);
+}
+export declare function fillMethod(rawMethod: RawMethodDefinition): MethodDefinition;

package/types/reflect-types/PropertyDefinition.d.ts

@@ -0,0 +1,18 @@
+import { type RawPropertyDefinition, type TypeDefinition } from './index';
+export declare class PropertyDefinition {
+    name: string;
+    isOptional: boolean;
+    isPrivate: boolean;
+    isStatic: boolean;
+    type: TypeDefinition;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+    constructor(def: RawPropertyDefinition);
+}
+export declare function fillProperty(rawProperty: RawPropertyDefinition): PropertyDefinition;

package/types/reflect-types/assert-type.d.ts

@@ -0,0 +1,12 @@
+import { type TypeDefinition } from '.';
+export type Type = string | {
+    array: Type;
+} | {
+    union: Type[];
+} | {
+    intersection: Type[];
+} | {
+    tuple: Type[];
+};
+export declare function getTypeDef(type: Type): TypeDefinition;
+export declare function assertType<T>(data: T, type: Type, depth?: number): T;

package/types/reflect-types/function-validate.d.ts

@@ -0,0 +1,10 @@
+import { type AnyFunction } from './package';
+declare const VALIDATE_WRAPPER: unique symbol;
+declare global {
+    interface Function {
+        [VALIDATE_WRAPPER]: AnyFunction;
+    }
+}
+export declare const ReflectValidate: MethodDecorator;
+export declare function safeCall(target: object, methodName: string, ...args: unknown[]): unknown;
+export {};

package/types/reflect-types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './reflect-definitions';
+export * from './reflect-context';
+export * from './ClassDefinition';
+export * from './InterfaceDefinition';
+export * from './EnumDefinition';
+export * from './MethodDefinition';
+export * from './PropertyDefinition';
+export * from './reflect-types';
+export * from './reflect-validate';
+export * from './assert-type';
+export * from './function-validate';

package/types/reflect-types/package.d.ts

@@ -0,0 +1,13 @@
+export type Dictionary<T> = {
+    [key: string]: T;
+};
+type Any = any;
+export type AnyConstructorFunction = new (...args: Any[]) => Any;
+export type AnyFunction = (...args: Any[]) => Any;
+export declare function setValue<T>(target: unknown, field: string | symbol, value: T): void;
+export declare function getValue<T>(target: unknown, field: string | symbol): T | undefined;
+export declare function mapNotNull<T, U>(arr: T[] | undefined, mapper: (item: T) => U | undefined): U[];
+export declare function spy(variables: {
+    [prop: string]: unknown;
+}): void;
+export {};

package/types/reflect-types/reflect-context.d.ts

@@ -0,0 +1,16 @@
+import type { AnyConstructorFunction } from './package';
+import { type TypeDefinition } from './index';
+import { ClassDefinition, EnumDefinition, InterfaceDefinition } from './index';
+export declare const ReflectClass: ClassDecorator;
+export declare const ReflectContext: {
+    getClassDefinition: typeof getClassDefinition;
+    getInterfaceDefinition: typeof getInterfaceDefinition;
+    getEnumDefinition: typeof getEnumDefinition;
+    getTypeAliasDefinition: typeof getTypeAliasDefinition;
+};
+export declare function getClassByName(className: string): AnyConstructorFunction | undefined;
+declare function getClassDefinition(arg: AnyConstructorFunction | object | string): ClassDefinition | undefined;
+declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
+export {};

package/types/reflect-types/reflect-definitions.d.ts

@@ -0,0 +1,100 @@
+import { PropertyDefinition } from './index';
+export interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    literalValue?: unknown;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: RawTypeDef[];
+}
+type RawTypeDef = string | RawTypeDefinition;
+export interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+export interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+export interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+export interface TypeDefinition {
+    name?: string;
+    arrayElementType?: TypeDefinition;
+    literalValue?: string;
+    typeLiteralMembers?: PropertyDefinition[];
+    unionMembers?: TypeDefinition[];
+    intersectionMembers?: TypeDefinition[];
+    isFunction?: boolean;
+    tupleMembers?: TypeDefinition[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: TypeDefinition[];
+}
+export declare function isIgnoredType(type: TypeDefinition): boolean;
+export declare function isPrimitiveType(type: TypeDefinition): type is {
+    name: string;
+};
+export declare function isArrayType(type: TypeDefinition): type is {
+    arrayElementType: TypeDefinition;
+};
+export declare function isLiteralType(type: TypeDefinition): type is {
+    literalValue: string;
+};
+export declare function isTypeLiteralType(type: TypeDefinition): type is {
+    typeLiteralMembers: PropertyDefinition[];
+};
+export declare function isUnionType(type: TypeDefinition): type is {
+    unionMembers: TypeDefinition[];
+};
+export declare function isIntersectionType(type: TypeDefinition): type is {
+    intersectionMembers: TypeDefinition[];
+};
+export declare function isTupleType(type: TypeDefinition): type is {
+    tupleMembers: TypeDefinition[];
+};
+export declare function hasGenerics(type: TypeDefinition): type is {
+    generics: TypeDefinition[];
+};
+export {};

package/types/reflect-types/reflect-types.d.ts

@@ -0,0 +1,20 @@
+import { type RawTypeDefinition, type TypeDefinition } from './index';
+import { ClassDefinition, EnumDefinition, InterfaceDefinition } from './index';
+import { type AnyConstructorFunction } from './package';
+export declare const anyType: {
+    name: string;
+};
+export declare const nullType: {
+    name: string;
+};
+export declare function getClassDefinition(arg: AnyConstructorFunction | object | string): ClassDefinition | undefined;
+export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+export declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
+export declare function getTypeDefinition(typeName: string): TypeDefinition;
+export declare function getEnumNames(enumName: string): string[];
+export declare function getEnumValues(args: {
+    [enumName: string]: Record<string, string | number>;
+}): (string | number)[];
+export declare function fillType(rawType: RawTypeDefinition | string | undefined): TypeDefinition;
+export type EnableReflect = object;

package/types/reflect-types/reflect-validate.d.ts

@@ -0,0 +1,24 @@
+import { type TypeDefinition } from './index';
+import { type Dictionary } from './package';
+interface ValidateResult {
+    success: boolean;
+    errorMessage?: string;
+}
+export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
+export declare function validateInstance<T extends object>(instance: T, typeName?: string, depth?: number): ValidateResult;
+export declare function validateArray<T extends object>(array: T[], typeName?: string, depth?: number): ValidateResult;
+export declare function validateDictionary<T extends object>(dict: Dictionary<T>, typeName?: string, depth?: number): ValidateResult;
+interface FailureResult extends ValidateResult {
+    cause?: FailureResult;
+}
+export declare function getErrorTraceMessages(failureResult: FailureResult): string;
+export declare function validateFunctionArgument(args: {
+    funcName: string;
+    optionsObj?: object;
+    value?: unknown;
+    argName: string;
+    type: string;
+    optional?: boolean;
+}): void;
+export declare function safeSetValue(target: object, propName: string, value: unknown): void;
+export {};