kea-typegen 3.2.2 → 3.3.0

package/src/print/printSharedListeners.ts

@@ -12,7 +12,6 @@ export function printSharedListeners(parsedLogic: ParsedLogic) {
                     undefined,
                     [
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('payload'),
@@ -21,7 +20,6 @@ export function printSharedListeners(parsedLogic: ParsedLogic) {
                             undefined,
                         ),
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('breakpoint'),
@@ -30,7 +28,6 @@ export function printSharedListeners(parsedLogic: ParsedLogic) {
                             undefined,
                         ),
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('action'),
@@ -39,7 +36,6 @@ export function printSharedListeners(parsedLogic: ParsedLogic) {
                             undefined,
                         ),
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('previousState'),

package/src/types.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { CloneNodeOptions } from '@wessberg/ts-clone-node'
+import { CloneNodeOptions } from 'ts-clone-node'
 
 export interface ActionTransform {
     name: string

package/src/utils.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript'
 import * as path from 'path'
-import { cloneNode } from '@wessberg/ts-clone-node'
+import { cloneNode } from 'ts-clone-node'
 import { visitProgram } from './visit/visit'
 import { parsedLogicToTypeString } from './print/print'
 import { AppOptions, NameType, ParsedLogic } from './types'
@@ -85,17 +85,16 @@ export function getAndGatherTypeNodeForDefaultValue(
 ): ts.TypeNode {
     const typeNode = getTypeNodeForNode(defaultValue, checker)
     gatherImports(typeNode, checker, parsedLogic)
-    return cloneNode(typeNode)
+    return cloneNodeSorted(typeNode)
 }
 
 export function getParameterDeclaration(param: ts.ParameterDeclaration) {
     return factory.createParameterDeclaration(
-        undefined,
         undefined,
         undefined,
         factory.createIdentifier(param.name.getText()),
         param.initializer || param.questionToken ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
-        cloneNode(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
+        cloneNodeSorted(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
         undefined,
     )
 }
@@ -197,7 +196,7 @@ export function extractImportedActions(
                                     }
                                 }
 
-                                extraActions[actionType] = cloneNode(actionCreator.type) //payload
+                                extraActions[actionType] = cloneNodeSorted(actionCreator.type) //payload
                             }
                         }
                     }
@@ -327,3 +326,110 @@ export function isAnyUnknown(node?: ts.Node): boolean {
         (ts.isTypeLiteralNode(unPromised) && unPromised.members.length === 0)
     )
 }
+
+const syntaxKindOrderOverride = (kind: ts.SyntaxKind): number => {
+    if (kind === ts.SyntaxKind.UndefinedKeyword) {
+        // sort undefineds at the end always
+        return 999
+    }
+    return kind
+}
+function compareNodes(a?: ts.Node, b?: ts.Node): number {
+    if (!a) {
+        if (!b) {
+            return 0
+        }
+        return -1
+    } else if (!b) {
+        return 1
+    }
+    if (ts.isLiteralTypeNode(a) && ts.isLiteralTypeNode(b)) {
+        if (ts.isStringLiteralLike(a.literal) && ts.isStringLiteralLike(b.literal)) {
+            return a.literal.text.localeCompare(b.literal.text)
+        } else if (ts.isNumericLiteral(a.literal) && ts.isNumericLiteral(b.literal)) {
+            return Number(a.literal.text) - Number(b.literal.text)
+        }
+        return a.literal.kind - b.literal.kind
+    } else if (ts.isTypeReferenceNode(a) && ts.isTypeReferenceNode(b)) {
+        try {
+            const textA = (a.typeName as any).escapedText || ''
+            const textB = (b.typeName as any).escapedText || ''
+            return textA.localeCompare(textB)
+        } catch (e) {
+            return 0
+        }
+    } else if (ts.isIdentifier(a) && ts.isIdentifier(b)) {
+        try {
+            const textA = (a as any).escapedText || ''
+            const textB = (b as any).escapedText || ''
+            return textA.localeCompare(textB)
+        } catch (e) {
+            return 0
+        }
+    } else if (ts.isImportTypeNode(a) && ts.isImportTypeNode(b)) {
+        const compare = compareNodes(a.argument, b.argument)
+        if (compare !== 0) {
+            return compare
+        }
+        return compareNodes(a.qualifier, b.qualifier)
+    } else if (ts.isUnionTypeNode(a) && ts.isUnionTypeNode(b)) {
+        if (a.types.length === b.types.length) {
+            for (let index = 0; index < a.types.length; index++) {
+                const compare = compareNodes(a.types[index], b.types[index])
+                if (compare !== 0) {
+                    return compare
+                }
+            }
+            return 0
+        }
+        return a.types.length - b.types.length
+    } else if (ts.isTypeLiteralNode(a) && ts.isTypeLiteralNode(b)) {
+        if (a.members.length === b.members.length) {
+            for (let index = 0; index < a.members.length; index++) {
+                const compare = compareNodes(a.members[index], b.members[index])
+                if (compare !== 0) {
+                    return compare
+                }
+                if (ts.isPropertySignature(a.members[index]) && ts.isPropertySignature(b.members[index])) {
+                    const typeCompare = compareNodes(
+                        (a.members[index] as ts.PropertySignature).type,
+                        (b.members[index] as ts.PropertySignature).type,
+                    )
+                    if (typeCompare !== 0) {
+                        return typeCompare
+                    }
+                }
+            }
+            return 0
+        }
+        return a.members.length - b.members.length
+    } else if (ts.isArrayTypeNode(a) && ts.isArrayTypeNode(b)) {
+        return compareNodes(a.elementType, b.elementType)
+    } else if (ts.isPropertySignature(a) && ts.isPropertySignature(b)) {
+        try {
+            return a.name.getText().localeCompare(b.name.getText())
+        } catch (e) {
+            return ((a.name as any).escapedText || '').localeCompare((b.name as any).escapedText || '')
+        }
+    } else if (b.kind === a.kind) {
+        // if (a.kind !== 148 && a.kind !== 152 && a.kind !== 155 && a.kind !== 131) {
+        //     debugger
+        // }
+    }
+    return syntaxKindOrderOverride(a.kind) - syntaxKindOrderOverride(b.kind)
+}
+
+export function cloneNodeSorted<T extends ts.Node>(node: T): T {
+    const visit = (node) => {
+        if (ts.isUnionTypeNode(node)) {
+            ;(node.types as any as ts.Node[]).sort(compareNodes)
+        }
+        if (ts.isTypeLiteralNode(node) && node.members.length > 1) {
+            ;(node.members as any as ts.Node[]).sort(compareNodes)
+        }
+        ts.forEachChild(node, visit)
+    }
+    const cloned = cloneNode(node)
+    visit(cloned)
+    return cloned
+}

package/src/visit/visit.ts

@@ -3,6 +3,7 @@ import * as path from 'path'
 import * as fs from 'fs'
 import { AppOptions, ParsedLogic, PluginModule, TypeBuilderModule, VisitKeaPropertyArguments } from '../types'
 import {
+    cloneNodeSorted,
     gatherImports,
     getFilenameForImportDeclaration,
     getFilenameForNode,
@@ -23,7 +24,7 @@ import { visitListeners } from './visitListeners'
 import { visitEvents } from './visitEvents'
 import { visitDefaults } from './visitDefaults'
 import { visitSharedListeners } from './visitSharedListeners'
-import { cloneNode } from '@wessberg/ts-clone-node'
+import { cloneNode } from 'ts-clone-node'
 
 const visitFunctions = {
     actions: visitActions,
@@ -376,11 +377,11 @@ export function visitKeaCalls(
                 node: expression,
                 checker,
                 gatherImports: (input) => gatherImports(input, checker, parsedLogic),
-                cloneNode,
+                cloneNode: cloneNodeSorted,
                 getTypeNodeForNode: (node) => getTypeNodeForNode(node, checker),
                 prepareForPrint: (node) => {
                     gatherImports(node, checker, parsedLogic)
-                    return cloneNode(node)
+                    return cloneNodeSorted(node)
                 },
             }
 

package/src/visit/visitActions.ts

@@ -1,8 +1,7 @@
 import { ParsedLogic } from '../types'
 import { factory, isFunctionLike, isPropertyAssignment, Expression, SyntaxKind, Type, TrueLiteral } from 'typescript'
 import { NodeBuilderFlags } from 'typescript'
-import { cloneNode } from '@wessberg/ts-clone-node'
-import { gatherImports } from '../utils'
+import { cloneNodeSorted, gatherImports } from '../utils'
 
 export function visitActions(parsedLogic: ParsedLogic, type: Type, expression: Expression) {
     const { checker } = parsedLogic
@@ -27,14 +26,13 @@ export function visitActions(parsedLogic: ParsedLogic, type: Type, expression: E
                     gatherImports(param.type, checker, parsedLogic)
                 }
                 return factory.createParameterDeclaration(
-                    undefined,
                     undefined,
                     undefined,
                     factory.createIdentifier(param.name.getText()),
                     param.initializer || param.questionToken
                         ? factory.createToken(SyntaxKind.QuestionToken)
                         : undefined,
-                    param.type ? cloneNode(param.type) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
+                    param.type ? cloneNodeSorted(param.type) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                     undefined,
                 )
             })
@@ -55,7 +53,7 @@ export function visitActions(parsedLogic: ParsedLogic, type: Type, expression: E
             }
 
             gatherImports(returnTypeNode, checker, parsedLogic)
-            returnTypeNode = cloneNode(returnTypeNode)
+            returnTypeNode = cloneNodeSorted(returnTypeNode)
         } else {
             // action is a value (action: true)
             returnTypeNode = factory.createTypeLiteralNode([

package/src/visit/visitConnect.ts

@@ -1,7 +1,6 @@
 import { ParsedLogic } from '../types'
 import * as ts from 'typescript'
-import { gatherImports, getParameterDeclaration } from '../utils'
-import { cloneNode } from '@wessberg/ts-clone-node'
+import { cloneNodeSorted, gatherImports, getParameterDeclaration } from '../utils'
 import { Expression, Type } from 'typescript'
 
 export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: Expression) {
@@ -74,7 +73,7 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
                                     if (ts.isTypeLiteralNode(returnType)) {
                                         const payload = returnType.members.find((m) => m.name.getText() === 'payload')
                                         if (ts.isPropertySignature(payload)) {
-                                            const returnTypeNode = cloneNode(payload.type)
+                                            const returnTypeNode = cloneNodeSorted(payload.type)
                                             gatherImports(actionType, checker, parsedLogic)
 
                                             parsedLogic.actions.push({

package/src/visit/visitKey.ts

@@ -1,6 +1,5 @@
 import { ParsedLogic } from '../types'
-import { cloneNode } from '@wessberg/ts-clone-node'
-import { gatherImports } from '../utils'
+import { cloneNodeSorted, gatherImports } from '../utils'
 import { Expression, Type } from 'typescript'
 
 export function visitKey(parsedLogic: ParsedLogic, type: Type, expression: Expression) {
@@ -8,5 +7,5 @@ export function visitKey(parsedLogic: ParsedLogic, type: Type, expression: Expre
     const typeNode = checker.typeToTypeNode(type, undefined, undefined)
     gatherImports(typeNode, checker, parsedLogic)
 
-    parsedLogic.keyType = cloneNode(typeNode)
+    parsedLogic.keyType = cloneNodeSorted(typeNode)
 }

package/src/visit/visitLoaders.ts

@@ -17,6 +17,7 @@ import {
     getAndGatherTypeNodeForDefaultValue,
     isAnyUnknown,
     unPromisify,
+    cloneNodeSorted,
 } from '../utils'
 import { NodeBuilderFlags } from 'typescript'
 
@@ -109,16 +110,14 @@ export function visitLoaders(parsedLogic: ParsedLogic, type: Type, expression: E
 
                     const successParameters = [
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier(loaderName),
                             undefined,
-                            returnTypeNode,
+                            cloneNodeSorted(returnTypeNode),
                             undefined,
                         ),
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('payload'),
@@ -132,7 +131,7 @@ export function visitLoaders(parsedLogic: ParsedLogic, type: Type, expression: E
                             undefined,
                             factory.createIdentifier(loaderName),
                             undefined,
-                            returnTypeNode,
+                            cloneNodeSorted(returnTypeNode),
                         ),
                         factory.createPropertySignature(
                             undefined,
@@ -151,7 +150,6 @@ export function visitLoaders(parsedLogic: ParsedLogic, type: Type, expression: E
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}Failure`)) {
                     const failureParameters = [
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('error'),
@@ -160,7 +158,6 @@ export function visitLoaders(parsedLogic: ParsedLogic, type: Type, expression: E
                             undefined,
                         ),
                         factory.createParameterDeclaration(
-                            undefined,
                             undefined,
                             undefined,
                             factory.createIdentifier('errorObject'),

package/src/visit/visitSelectors.ts

@@ -1,8 +1,7 @@
 import { ParsedLogic } from '../types'
 import * as ts from 'typescript'
 import { Expression, NodeBuilderFlags, Type } from 'typescript'
-import { cloneNode } from '@wessberg/ts-clone-node'
-import { gatherImports } from '../utils'
+import { cloneNodeSorted, gatherImports } from '../utils'
 
 export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression: Expression) {
     const { checker } = parsedLogic
@@ -48,7 +47,7 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
                         return {
                             name,
                             type: ts.isFunctionTypeNode(selectorTypeNode)
-                                ? cloneNode(selectorTypeNode.type)
+                                ? cloneNodeSorted(selectorTypeNode.type)
                                 : ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
                         }
                     })
@@ -62,10 +61,11 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
                 let typeNode: ts.TypeNode
                 if (computedFunction.type) {
                     gatherImports(computedFunction.type, checker, parsedLogic)
-                    typeNode = cloneNode(computedFunction.type)
+                    typeNode = cloneNodeSorted(computedFunction.type)
                 } else if (type) {
                     typeNode = checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation)
                     gatherImports(typeNode, checker, parsedLogic)
+                    typeNode = cloneNodeSorted(typeNode)
                 } else {
                     typeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                 }

package/src/visit/visitSharedListeners.ts

@@ -1,7 +1,6 @@
 import { ParsedLogic } from '../types'
 import * as ts from 'typescript'
-import { cloneNode } from '@wessberg/ts-clone-node'
-import { gatherImports } from '../utils'
+import { cloneNodeSorted, gatherImports } from '../utils'
 import { Expression, Type } from 'typescript'
 
 export function visitSharedListeners(parsedLogic: ParsedLogic, type: Type, expression: Expression) {
@@ -15,7 +14,7 @@ export function visitSharedListeners(parsedLogic: ParsedLogic, type: Type, expre
             let typeNode
             const firstParameter = value.parameters[0]
             if (firstParameter) {
-                typeNode = cloneNode(
+                typeNode = cloneNodeSorted(
                     checker.typeToTypeNode(checker.getTypeAtLocation(firstParameter), undefined, undefined),
                 )
                 gatherImports(typeNode, checker, parsedLogic)