@luna-park/plugin 1.3.0 → 1.4.0

package/dist/extractor.d.ts

@@ -1,247 +0,0 @@
-import { default as default_2 } from 'typescript';
-import * as ts from 'typescript';
-
-export declare class CTypeExport {
-    program: default_2.Program;
-    checker: default_2.TypeChecker;
-    index?: default_2.SourceFile;
-    private cache;
-    private result?;
-    constructor(program: default_2.Program);
-    get(target: string): TExportResult;
-    exportModule(module: default_2.Symbol): void;
-    exportComponent(name: string, type: default_2.Type): void;
-    exportFunction(name: string, signature: default_2.Signature): void;
-    extractType(type: default_2.Type, ctxNode?: default_2.Node): void;
-    typeToString(type: default_2.Type, flags?: number): string;
-}
-
-declare enum EVarType {
-    exec = "exec",
-    number = "number",
-    string = "string",
-    boolean = "boolean",
-    object = "object",
-    record = "record",
-    array = "array",
-    interface = "interface",
-    type = "type",
-    function = "function",
-    union = "union",
-    unknown = "unknown",
-    undefined = "undefined",
-    void = "void"
-}
-
-export declare function extractFile(filePath: string, target: string): Promise<void>;
-
-export declare function generateNodes(exportResult: TExportResult, packageName?: string): TExportLogicResult;
-
-export declare function getSourceFile(moduleName: string): {
-    program: ts.Program;
-    sourceFile: ts.SourceFile;
-};
-
-declare type OptionalKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends {
-        optional: true;
-    } ? K : never;
-}[keyof T];
-
-declare type RequiredKeys<T extends TProperties> = Exclude<keyof T, OptionalKeys<T>>;
-
-declare type Static<T extends TSchema> = T extends {
-    optional: true;
-} ? (T["static"] | undefined) : T["static"];
-
-declare type StaticFunction<TInputs extends TObject, TOutput extends TSchema, TPromise extends boolean = false> = TPromise extends true ? (...args: Array<Static<TInputs>[string]>) => Promise<Static<TOutput>> : (...args: Array<Static<TInputs>[string]>) => Static<TOutput>;
-
-declare type StaticObject<T extends TProperties> = {
-    [K in RequiredKeys<T>]: Static<T[K]>;
-} & {
-    [K in OptionalKeys<T>]?: Static<T[K]>;
-};
-
-declare type StaticRecord<TKey extends TSchema, TValue extends TSchema> = Record<Static<TKey>, Static<TValue>>;
-
-declare type StaticUnion<T extends Array<TSchema>> = {
-    [K in keyof T]: Static<T[K]>;
-}[number];
-
-declare type TAnyLogic = TExec | TObject | TRecord<any, any> | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
-
-declare interface TArguments<TType = unknown> {
-    build?: (arg: unknown) => unknown;
-    customizable?: boolean;
-    default?: TType | (() => TType);
-    defaultType?: TSchema;
-    description?: string;
-    dynamic?: ((arg: {
-        config: Record<string, unknown>;
-        inputs: Record<string, TSchema>;
-        outputs: Record<string, TSchema>;
-    }) => TSchema);
-    enum?: TEnum<TType>;
-    example?: unknown;
-    format?: "date-time" | "email" | "color";
-    multiple?: boolean;
-    name?: string;
-    optional?: boolean;
-    options?: {
-        access?: TSchema<TObject>;
-        format?: (arg: TType) => TType;
-        freeze?: boolean;
-        readonly?: boolean;
-    } & Record<string, unknown>;
-    parse?: (arg: unknown) => unknown;
-    placeholder?: string;
-    priority?: boolean;
-    promise?: boolean;
-    required?: boolean;
-    static?: unknown;
-    sub?: TSchema;
-}
-
-declare interface TArray<T extends TSchema = TSchema> {
-    items: T;
-    static: Array<Static<T>>;
-    type: EVarType.array;
-}
-
-declare interface TBoolean {
-    static: boolean;
-    type: EVarType.boolean;
-}
-
-declare type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
-
-declare interface TExec {
-    type: EVarType.exec;
-}
-
-declare type TExportComponent = {
-    emits?: Record<string, Array<TExportType>>;
-    models?: Record<string, TExportType>;
-    properties?: Record<string, TExportType>;
-    slots?: Record<string, TExportType>;
-};
-
-declare type TExportFunction = {
-    description?: string;
-    parameters?: Array<{
-        default?: string;
-        description?: string;
-        name: string;
-        optional?: boolean;
-        type: string;
-    }>;
-    return: {
-        description?: string;
-        type: string;
-    };
-    type: string;
-};
-
-declare type TExportLogicComponent = {
-    emits: Record<string, TSchema>;
-    models: Record<string, TSchema>;
-    properties: Record<string, TSchema>;
-    slots: Record<string, TSchema>;
-};
-
-declare type TExportLogicResult = {
-    components: Record<string, TExportLogicComponent>;
-    functions: Record<string, TExportNodeFunction>;
-    types: Record<string, TSchema>;
-};
-
-declare type TExportNodeFunction = {
-    description?: string;
-    name?: string;
-    parameters?: Array<TSchema>;
-    return?: TSchema;
-};
-
-declare type TExportResult = {
-    components: Record<string, TExportComponent>;
-    functions: Record<string, TExportFunction>;
-    types: Record<string, TExportType>;
-};
-
-declare type TExportType = {
-    default?: string;
-    description?: string;
-    optional?: boolean;
-    properties?: Record<string, TExportType>;
-    type: string | Record<string, TExportType>;
-};
-
-declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown, TPromise extends boolean = false> {
-    inputs: TInputs;
-    output: TOutput;
-    static: StaticFunction<TInputs, TOutput, TPromise>;
-    type: EVarType.function;
-}
-
-declare interface TInterface<T = unknown> {
-    class?: new (...args: any) => T;
-    className: string;
-    static: T;
-    type: EVarType.interface;
-}
-
-declare interface TNumber {
-    static: number;
-    type: EVarType.number;
-}
-
-declare interface TObject<T extends TProperties = TProperties> {
-    properties: T;
-    static: StaticObject<T>;
-    type: EVarType.object;
-}
-
-declare type TProperties = Record<string, TSchema>;
-
-declare interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
-    key: TKey;
-    static: StaticRecord<TKey, TValue>;
-    type: EVarType.record;
-    value: TValue;
-}
-
-declare type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TArguments & TLogic;
-
-declare interface TString {
-    static: string;
-    type: EVarType.string;
-}
-
-declare interface TType<T extends TSchema = TSchema> {
-    static: T;
-    target: Array<string>;
-    type: EVarType.type;
-}
-
-declare interface TUndefined {
-    static: undefined;
-    type: EVarType.undefined;
-}
-
-declare interface TUnion<T extends Array<TSchema> = Array<TSchema>> {
-    elements: T;
-    static: StaticUnion<T>;
-    type: EVarType.union;
-}
-
-declare interface TUnknown {
-    static: unknown;
-    type: EVarType.unknown;
-}
-
-declare interface TVoid {
-    static: void;
-    type: EVarType.void;
-}
-
-export { }