@player-tools/xlr-converters 0.0.2-next.0

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import ts from 'typescript';
+import { NodeType, NamedType, ObjectType, NamedTypeWithGenerics } from '@player-tools/xlr';
+import { TopLevelDeclaration } from '@player-tools/xlr-utils';
+
+interface TSConverterContext {
+    /** */
+    customPrimitives: Array<string>;
+    /** */
+    typeChecker: ts.TypeChecker;
+    /** */
+    throwError: (message: string) => never;
+    /** Cached conversion operations */
+    cache: {
+        /** Converted TS Nodes */
+        convertedNodes: Map<ts.TypeNode, NodeType | undefined>;
+        /** Processed Template Strings */
+        convertedTemplates: Map<ts.TemplateLiteralTypeNode, string>;
+    };
+}
+/** Converts TS Nodes/Files to XLRs */
+declare class TsConverter {
+    private context;
+    constructor(typeChecker: ts.TypeChecker, customPrimitives?: Array<string>);
+    /** Converts all exported objects to a XLR representation */
+    convertSourceFile(sourceFile: ts.SourceFile): {
+        data: {
+            version: number;
+            types: NamedType<NodeType>[];
+        };
+        convertedTypes: string[];
+    };
+    /** Converts a single type/interface declaration to XLRs */
+    convertDeclaration(node: TopLevelDeclaration): NamedType<ObjectType> | NamedTypeWithGenerics<ObjectType>;
+    /** Converts an arbitrary ts.TypeNode to XLRs */
+    convertTsTypeNode(node: ts.TypeNode): NodeType | undefined;
+    private tsNodeToType;
+    private fromTsObjectMembers;
+    private fromTsTuple;
+    private handleHeritageClauses;
+    private solveGenerics;
+    private generateGenerics;
+    private resolveRefNode;
+}
+
+interface ConvertedType {
+    /** Converted input type represented as in TS Nodes */
+    type: TopLevelDeclaration;
+    /** Types that may require import statements to be added */
+    referencedTypes?: Set<string>;
+    /** Any additionally referenced types that were deserialized that should be separate declarations */
+    additionalTypes?: Map<string, TopLevelDeclaration>;
+}
+/** */
+declare class TSWriter {
+    private context;
+    private importSet;
+    private additionalTypes;
+    constructor(factory?: ts.NodeFactory);
+    convertNamedType(type: NamedType): ConvertedType;
+    private convertNamedTypeNode;
+    private convertTypeNode;
+    private createRefNode;
+    private createPrimitiveNode;
+    private createLiteralTypeNode;
+    private createTupleNode;
+    private createFunctionDeclarationNode;
+    private createRecordNode;
+    private createConditionalTypeNode;
+    private createObjectNode;
+    private createTemplateLiteral;
+    private createGenericArgumentNode;
+    private makeAnnotations;
+    private createTypeParameters;
+    private makeInterfaceDeclaration;
+    private makeTypeDeclaration;
+}
+
+/**
+ * Specific error that can be caught to indicate an error in conversion
+ */
+declare class ConversionError extends Error {
+    constructor(msg: string);
+    toString(): string;
+}
+
+export { ConversionError, ConvertedType, TSConverterContext, TSWriter, TsConverter };