ts-ref-kit 1.0.12 → 1.0.15

package/dist/types/index.d.ts

@@ -0,0 +1,455 @@
+export declare const AfterSerialized: PropertyDecorator;
+
+export declare type Any = any;
+
+declare type Any_2 = any;
+
+export declare type AnyConstructorFunction = new (...args: Any[]) => Any;
+
+declare type AnyConstructorFunction_2 = new (...args: Any_2[]) => Any_2;
+
+export declare type AnyFunction = (...args: Any[]) => Any;
+
+export declare type AnyObject = Dictionary<Any>;
+
+export declare const anyType: {
+    name: string;
+};
+
+export declare function asBoolean(value: unknown): boolean;
+
+export declare function asNumber(v: unknown): number;
+
+export declare function assertType<T>(data: unknown, type: Type, depth?: number): T;
+
+export declare function asString(v: unknown): string;
+
+export declare function callDecoratedMethod<Self extends object>(self: Self, metaKey: symbol, ...args: Any[]): Any | undefined;
+
+export declare type Class<T> = new (...args: Any[]) => T;
+
+export declare class ClassDefinition {
+    readonly name: string;
+    readonly superClassName: string;
+    readonly superClass: ClassDefinition | undefined;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition_2[];
+    readonly jsClass: AnyConstructorFunction_2;
+    private readonly _implementationNames;
+    private readonly _implementations?;
+    private _allImplementations?;
+    constructor(def: RawClassDefinition & {
+        jsClass: AnyConstructorFunction_2;
+    });
+    get allMethods(): Dictionary_2<MethodDefinition>;
+    get allProperties(): Dictionary_2<PropertyDefinition_2>;
+    get implementations(): ImplementationOfClass[];
+    get allImplementations(): ImplementationOfClass[];
+    getProperty(propName: string): PropertyDefinition_2 | undefined;
+    get type(): TypeDefinition;
+    isSubClassOf(typeName: string): boolean;
+    isSuperClassOf(typeName: string): boolean;
+    toString(): string;
+}
+
+export declare type ClassOrInstance<T> = T | Class<T>;
+
+export declare function createNewInstance<T>(clazz: Class<T>): any;
+
+export declare function defineDecoratedProperty(metaKey: symbol): PropertyDecorator;
+
+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 type Dictionary<T> = {
+    [key: string | symbol]: T;
+};
+
+declare type Dictionary_2<T> = {
+    [key: string]: T;
+};
+
+export declare const done: () => any;
+
+export declare type EnableReflect = object;
+
+export declare class EnumDefinition {
+    readonly name: string;
+    readonly members: Map<string, TypeDefinition>;
+    constructor(def: RawEnumDefinition);
+    get type(): TypeDefinition;
+    get names(): string[];
+}
+
+declare interface FailureResult extends ValidateResult {
+    cause?: FailureResult;
+}
+
+export declare function fillMethod(rawMethod: RawMethodDefinition): MethodDefinition;
+
+export declare function fillProperty(rawProperty: RawPropertyDefinition): PropertyDefinition_2;
+
+export declare function fillType(rawType: RawTypeDefinition | string | undefined): TypeDefinition;
+
+declare type FromJSON<T> = (jsonValue: JsonValue) => T;
+
+export declare function getAnyValue<T>(target: Any, field: string | number | symbol): T | undefined;
+
+export declare function getClassByName(className: string): AnyConstructorFunction_2 | undefined;
+
+export declare function getClassDefinition(arg: AnyConstructorFunction_2 | object | string): ClassDefinition | undefined;
+
+declare function getClassDefinition_2(arg: AnyConstructorFunction_2 | object | string): ClassDefinition | undefined;
+
+export declare function getDecoratedProperty(target: object, metaKey: symbol): ReflectPropertyKey | undefined;
+
+export declare function getDecoratedPropertyValue<V>(target: object, metaKey: symbol): V | undefined;
+
+export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+
+declare function getEnumDefinition_2(name: string): EnumDefinition | undefined;
+
+export declare function getEnumNames(enumName: string): string[];
+
+export declare function getEnumValues(args: {
+    [enumName: string]: Record<string, string | number>;
+}): (string | number)[];
+
+export declare function getErrorTraceMessages(failureResult: FailureResult): string;
+
+export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+
+declare function getInterfaceDefinition_2(name: string): InterfaceDefinition | undefined;
+
+export declare function getOrSetValue<T>(target: Any, field: string | number | symbol, defaultWith: () => T): T;
+
+export declare function getSerializeSettings(clazz: Class<Any>): any;
+
+export declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
+
+declare function getTypeAliasDefinition_2(name: string): TypeDefinition | undefined;
+
+export declare function getTypeDef(type: Type | TypeDefinition): TypeDefinition;
+
+export declare function getTypeDefinition(typeName: string): TypeDefinition;
+
+export declare function hasDecoratedMethod<Self extends object>(self: Self, metaKey: symbol): boolean;
+
+export declare function hasGenerics(type: TypeDefinition): type is {
+    generics: TypeDefinition[];
+};
+
+export declare const IgnoreSerialization: PropertyDecorator;
+
+declare type ImplementationOfClass = InterfaceDefinition | TypeDefinition;
+
+declare type ImplementationOfInterface = InterfaceDefinition | ClassDefinition | TypeDefinition;
+
+export declare class InterfaceDefinition {
+    readonly name: string;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition_2[];
+    private readonly _implementationNames;
+    private _implementations?;
+    private _allImplementations?;
+    constructor(def: RawInterfaceDefinition);
+    get implementations(): ImplementationOfInterface[];
+    get allImplementations(): ImplementationOfInterface[];
+    get type(): TypeDefinition;
+    toString(): string;
+    buildBaseObject(): {};
+}
+
+declare 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 isArrayType(type: TypeDefinition): type is {
+    arrayElementType: TypeDefinition;
+};
+
+export declare function isClassDefinition(type: TypeDefinition): type is {
+    classDefinition: ClassDefinition;
+};
+
+export declare function isDictionary(value: Any): boolean;
+
+export declare function isIgnoredType(type: TypeDefinition): boolean;
+
+export declare function isIntersectionType(type: TypeDefinition): type is {
+    intersectionMembers: TypeDefinition[];
+};
+
+export declare function isLiteralType(type: TypeDefinition): type is {
+    literalValue: string;
+};
+
+export declare function isNullable(type: Type | TypeDefinition): boolean;
+
+export declare function isPrimitiveType(type: TypeDefinition): type is {
+    name: string;
+};
+
+export declare function isTupleType(type: TypeDefinition): type is {
+    tupleMembers: TypeDefinition[];
+};
+
+export declare function isType(value: unknown, type: Type | TypeDefinition): boolean;
+
+export declare function isTypeLiteralType(type: TypeDefinition): type is {
+    typeLiteralMembers: PropertyDefinition_2[];
+};
+
+export declare function isUnionType(type: TypeDefinition): type is {
+    unionMembers: TypeDefinition[];
+};
+
+export declare const itSelf: (some: Any) => any;
+
+export declare type JsonObject = {
+    [propName: string]: JsonValue;
+};
+
+export declare type JsonValue = string | number | boolean | null | JsonObject | JsonObject[];
+
+export declare interface JsonValueTransform<T> {
+    fromJson: FromJSON<T>;
+    toJson: ToJSON<T>;
+}
+
+export declare function Lazy(creator: (self: object, property: ReflectPropertyKey) => Any): PropertyDecorator;
+
+export declare function mapAllProperties<T extends Mappable>(target: T, map: Mapping<T>): void;
+
+export declare interface Mappable extends EnableReflect {
+    mapping(map: Mapping<Mappable>): void;
+}
+
+export declare type Mapping<T extends Mappable> = {
+    [propName in keyof T]-?: (fieldName?: string | symbol, transform?: {
+        fromJSON?: (jsonValue: JsonValue) => Mappable;
+        toJSON?: (obj: Mappable) => JsonValue;
+    }) => void;
+};
+
+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 type Nullable<T> = T | null;
+
+export declare const nullType: {
+    name: string;
+};
+
+export declare type Optional<T> = T | undefined;
+
+declare class PropertyDefinition_2 {
+    name: string;
+    isOptional: boolean;
+    isPrivate: boolean;
+    isStatic: boolean;
+    type: TypeDefinition;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+    constructor(def: RawPropertyDefinition);
+}
+export { PropertyDefinition_2 as PropertyDefinition }
+
+export declare const PropertyWrapper: IPropertyWrapper;
+
+export declare interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+
+export declare interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+
+export declare interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+
+export declare interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+
+export declare interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+
+declare type RawTypeDef = string | RawTypeDefinition;
+
+export declare interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    literalValue?: unknown;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: RawTypeDef[];
+}
+
+export declare const ReflectClass: ClassDecorator;
+
+export declare const ReflectContext: {
+    getClassDefinition: typeof getClassDefinition_2;
+    getInterfaceDefinition: typeof getInterfaceDefinition_2;
+    getEnumDefinition: typeof getEnumDefinition_2;
+    getTypeAliasDefinition: typeof getTypeAliasDefinition_2;
+};
+
+export declare type ReflectPropertyKey = string | symbol;
+
+export declare type ReflectType = StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | FunctionConstructor | AnyConstructorFunction;
+
+export declare const ReflectValidate: MethodDecorator;
+
+export declare function registerMappable<T extends Mappable>(mappableClass: Class<T>): void;
+
+export declare function registerSerializedProperty(target: AnyObject, propName: string, options: SerializedOptions<Any>): void;
+
+export declare function registerTransform<T>(clazz: Class<T>, transform: JsonValueTransform<T>): void;
+
+export declare function safeCall(target: object, methodName: string, ...args: unknown[]): unknown;
+
+export declare function safeSetValue(target: object, propName: string, value: unknown): void;
+
+/**
+ * serialize an object to json string
+ */
+export declare function serialize<T>(value: T): string;
+
+export declare function Serialized<T extends object>(options?: SerializedOptions<T>): PropertyDecorator;
+
+export declare const SerializedClass: PropertyDecorator;
+
+export declare function SerializedName(serializedName: string): PropertyDecorator;
+
+declare type SerializedOptions<T> = {
+    name?: string;
+    class?: Class<T>;
+    fromJSON?: FromJSON<T>;
+    toJSON?: ToJSON<T>;
+};
+
+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 setAnyValue<T>(target: Any, field: string | number | symbol, value: T): void;
+
+export declare function setDefaultIgnored(clazz: Class<Any>, defaultIgnored: boolean): void;
+
+declare type ToJSON<T> = (obj: T) => JsonValue;
+
+export declare type Type = string | {
+    array: Type;
+} | {
+    union: Type[];
+} | {
+    intersection: Type[];
+} | {
+    tuple: Type[];
+};
+
+export declare interface TypeDefinition {
+    name?: string;
+    arrayElementType?: TypeDefinition;
+    literalValue?: string;
+    typeLiteralMembers?: PropertyDefinition_2[];
+    unionMembers?: TypeDefinition[];
+    intersectionMembers?: TypeDefinition[];
+    isFunction?: boolean;
+    tupleMembers?: TypeDefinition[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: TypeDefinition[];
+    classDefinition?: ClassDefinition;
+}
+
+export declare function validateArray<T extends object>(array: T[], typeName?: string, depth?: number): ValidateResult;
+
+export declare function validateDictionary<T extends object>(dict: Dictionary_2<T>, typeName?: string, depth?: number): ValidateResult;
+
+export declare function validateFunctionArgument(args: {
+    funcName: string;
+    optionsObj?: object;
+    value?: unknown;
+    argName: string;
+    type: string;
+    optional?: boolean;
+}): void;
+
+export declare function validateInstance<T extends object>(instance: T, typeName?: string, depth?: number): ValidateResult;
+
+declare interface ValidateResult {
+    success: boolean;
+    errorMessage?: string;
+}
+
+export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
+
+export { }

package/{types/parser/reflect-parser.d.ts → dist/types/parser/index.d.ts}

@@ -1,77 +1,110 @@
-export declare const DEBUG_CONFIG: {
-    OUTPUT_LOG: boolean;
-};
-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 {};
+import { Plugin as Plugin_2 } from 'vite';
+
+declare type Any = any;
+
+export declare const DEBUG_CONFIG: {
+    OUTPUT_LOG: boolean;
+};
+
+declare type FilePathRule = string | RegExp | (string | RegExp)[];
+
+declare interface Options extends ReflectLoaderOptions {
+    entry: string;
+}
+
+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 declare interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+
+export declare interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+
+export declare interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+    indexElementType?: RawTypeDef;
+}
+
+export declare interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+
+export declare interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+
+declare type RawTypeDef = string | RawTypeDefinition;
+
+export declare interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    indexElementType?: RawTypeDef;
+    literalValue?: Any;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    generics?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+}
+
+export declare function reflectLoader(options: ReflectLoaderOptions): {
+    outputAllMetas: () => string;
+    transform: (sourceCode: string, sourceFileName: string) => string;
+};
+
+export declare interface ReflectLoaderOptions {
+    sourcePaths: string | string[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    forEnabledClassOnly?: boolean;
+    outputLog?: boolean;
+}
+
+export declare function reflectParserPlugin(options: Options): Plugin_2;
+
+export declare function setupReflectTypes(filePaths: string | string[], exclude?: FilePathRule, distFolder?: string): Promise<void>;
+
+export declare function updateReflectModules(filePath: string, distFolder: string): Promise<void>;
+
+export { }

package/dist/types/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.52.11"
+    }
+  ]
+}