expo-type-information 0.0.0 → 0.0.2

package/build/typescriptGeneration.js

@@ -0,0 +1,696 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultGenerationContext = createDefaultGenerationContext;
+exports.getBasicTypesIdentifiers = getBasicTypesIdentifiers;
+exports.joinTSNodesWithNewlines = joinTSNodesWithNewlines;
+exports.mapTypeToTsTypeNode = mapTypeToTsTypeNode;
+exports.buildViewPropsInterface = buildViewPropsInterface;
+exports.buildFunction = buildFunction;
+exports.buildConstructor = buildConstructor;
+exports.buildClass = buildClass;
+exports.buildUnknownTypeAlias = buildUnknownTypeAlias;
+exports.buildRecordTypeAlias = buildRecordTypeAlias;
+exports.buildEnumTypeDeclaration = buildEnumTypeDeclaration;
+exports.buildExposedTypesDeclarations = buildExposedTypesDeclarations;
+exports.getViewPropsTypeName = getViewPropsTypeName;
+exports.prettifyCode = prettifyCode;
+exports.generateViewTypesFileContent = generateViewTypesFileContent;
+exports.generateJSXIntrinsicsFileContent = generateJSXIntrinsicsFileContent;
+exports.generateModuleTypesFileContent = generateModuleTypesFileContent;
+exports.generateConciseTsInterface = generateConciseTsInterface;
+exports.generateFullTsInterface = generateFullTsInterface;
+const prettier_1 = __importDefault(require("prettier"));
+const typescript_1 = __importDefault(require("typescript"));
+const typeInformation_1 = require("./typeInformation");
+const prefix = `Automatically generated by expo-type-information.`;
+const exportModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword);
+const declareModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword);
+const asyncModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.AsyncKeyword);
+const readonlyModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ReadonlyKeyword);
+const constModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ConstKeyword);
+const defaultModifier = () => typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.DefaultKeyword);
+const unknownKeywordType = () => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.UnknownKeyword);
+const anyKeywordType = () => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.AnyKeyword);
+const voidKeywordType = () => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword);
+const newlineIdentifier = () => typescript_1.default.factory.createIdentifier('\n\n');
+let freeId = 0;
+function getNextFreeId() {
+    freeId += 1;
+    return freeId;
+}
+function createDefaultGenerationContext(fileInfo) {
+    const module = fileInfo.moduleClasses[0];
+    if (!module) {
+        return null;
+    }
+    const view = module.views[0] ?? null;
+    return {
+        fileInfo,
+        module,
+        view,
+        missingTypes: getMissingTypeIdentifiers(fileInfo),
+    };
+}
+function getBasicTypesIdentifiers() {
+    return new Set(['any', 'number', 'string', 'undefined', 'null', 'Map', 'Set', 'Promise']);
+}
+function getAllNonBasicTypes(fileInfo) {
+    return fileInfo.declaredTypeIdentifiers
+        .union(fileInfo.usedTypeIdentifiers)
+        .difference(getBasicTypesIdentifiers());
+}
+function createGeneratedPrefix() {
+    return [
+        typescript_1.default.addSyntheticLeadingComment(typescript_1.default.factory.createIdentifier(''), typescript_1.default.SyntaxKind.MultiLineCommentTrivia, prefix),
+    ];
+}
+function constructModifiersArray(modifiers) {
+    const modifiersArray = [];
+    if (modifiers.exported)
+        modifiersArray.push(exportModifier());
+    if (modifiers.declare)
+        modifiersArray.push(declareModifier());
+    if (modifiers.async)
+        modifiersArray.push(asyncModifier());
+    if (modifiers.readonly)
+        modifiersArray.push(readonlyModifier());
+    return modifiersArray;
+}
+function joinTSNodesWithNewlines(nodes) {
+    const new_nodes = [];
+    for (const node of nodes) {
+        if (node.length > 0) {
+            new_nodes.push(...node);
+            new_nodes.push(newlineIdentifier());
+        }
+    }
+    return new_nodes;
+}
+function mapBasicTypeToTypeNode(basicType) {
+    if (basicType === typeInformation_1.BasicType.UNRESOLVED) {
+        return typescript_1.default.addSyntheticTrailingComment(unknownKeywordType(), typescript_1.default.SyntaxKind.MultiLineCommentTrivia, "The type couldn't be resolved automatically.");
+    }
+    const BASIC_TYPE_MAP = {
+        [typeInformation_1.BasicType.ANY]: typescript_1.default.SyntaxKind.AnyKeyword,
+        [typeInformation_1.BasicType.BOOLEAN]: typescript_1.default.SyntaxKind.BooleanKeyword,
+        [typeInformation_1.BasicType.NUMBER]: typescript_1.default.SyntaxKind.NumberKeyword,
+        [typeInformation_1.BasicType.STRING]: typescript_1.default.SyntaxKind.StringKeyword,
+        [typeInformation_1.BasicType.VOID]: typescript_1.default.SyntaxKind.VoidKeyword,
+        [typeInformation_1.BasicType.UNDEFINED]: typescript_1.default.SyntaxKind.UndefinedKeyword,
+        [typeInformation_1.BasicType.UNRESOLVED]: typescript_1.default.SyntaxKind.UndefinedKeyword, // This is handled earlier
+    };
+    return typescript_1.default.factory.createKeywordTypeNode(BASIC_TYPE_MAP[basicType]);
+}
+function mapTypeToTsTypeNode(type) {
+    switch (type.kind) {
+        case typeInformation_1.TypeKind.BASIC:
+            return mapBasicTypeToTypeNode(type.type);
+        case typeInformation_1.TypeKind.IDENTIFIER:
+            return typescript_1.default.factory.createTypeReferenceNode(type.type);
+        case typeInformation_1.TypeKind.SUM:
+            return typescript_1.default.factory.createUnionTypeNode(type.type.types.map(mapTypeToTsTypeNode));
+        case typeInformation_1.TypeKind.ARRAY:
+            return typescript_1.default.factory.createArrayTypeNode(mapTypeToTsTypeNode(type.type));
+        case typeInformation_1.TypeKind.DICTIONARY: {
+            const dictionaryType = type.type;
+            const name = 'key';
+            const typeNode = mapTypeToTsTypeNode(dictionaryType.key);
+            const valueType = mapTypeToTsTypeNode(dictionaryType.value);
+            return typescript_1.default.factory.createTypeLiteralNode([
+                typescript_1.default.factory.createIndexSignature(undefined, [createParameter({ name, type: typeNode })], valueType),
+            ]);
+        }
+        // Technically this one should only be the top one and it should be handled somewhere else
+        // for example when creating arguemnt adding the '?' token.
+        //
+        // However we can just make it (type | undefined) in here.
+        // TODO(@HubertBer): Maybe also need null?
+        case typeInformation_1.TypeKind.OPTIONAL:
+            return typescript_1.default.factory.createUnionTypeNode([
+                mapTypeToTsTypeNode(type.type),
+                mapBasicTypeToTypeNode(typeInformation_1.BasicType.UNDEFINED),
+            ]);
+        case typeInformation_1.TypeKind.PARAMETRIZED:
+            return typescript_1.default.factory.createTypeReferenceNode(type.type.name, type.type.types.map(mapTypeToTsTypeNode));
+    }
+    return mapBasicTypeToTypeNode(typeInformation_1.BasicType.UNRESOLVED);
+}
+//
+// ts.factory wrapper functions
+//
+function createImportDeclaration({ defaultImportName, namedImportsNames, importFromName, }) {
+    const hasDefault = !!defaultImportName;
+    const hasNamed = namedImportsNames && namedImportsNames.length > 0;
+    if (!hasDefault && !hasNamed) {
+        return [];
+    }
+    const defaultImport = hasDefault ? typescript_1.default.factory.createIdentifier(defaultImportName) : undefined;
+    const namedImports = hasNamed
+        ? typescript_1.default.factory.createNamedImports(namedImportsNames.map((name) => typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier(name))))
+        : undefined;
+    return [
+        typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(undefined, defaultImport, namedImports), typescript_1.default.factory.createStringLiteral(importFromName)),
+    ];
+}
+function createParameter({ modifiers, name, type, questionToken, dotDotDotToken, initializer, }) {
+    return typescript_1.default.factory.createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer);
+}
+function createProperty({ modifiers, name, typeNode, initializer, optional, }) {
+    return typescript_1.default.factory.createPropertyDeclaration(modifiers, name, optional ? typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken) : undefined, typeNode, initializer);
+}
+function createPropertySignature({ name, typeNode, optional, modifiers, }) {
+    return typescript_1.default.factory.createPropertySignature(modifiers, name, optional ? typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken) : undefined, typeNode);
+}
+function createCall({ expression, args, typeArgs, }) {
+    return typescript_1.default.factory.createCallExpression(typeof expression === 'string' ? typescript_1.default.factory.createIdentifier(expression) : expression, typeArgs, args);
+}
+function createRequireNativeModuleExpression({ moduleType, moduleName, }) {
+    return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('requireNativeModule'), moduleType ? [typescript_1.default.factory.createTypeReferenceNode(moduleType)] : undefined, [typescript_1.default.factory.createStringLiteral(moduleName)]);
+}
+function createExportDefaultAsDeclaration({ exportAsName, importFromName, }) {
+    return [
+        typescript_1.default.factory.createExportDeclaration(undefined, false, typescript_1.default.factory.createNamedExports([
+            typescript_1.default.factory.createExportSpecifier(false, typescript_1.default.factory.createIdentifier('default'), typescript_1.default.factory.createIdentifier(exportAsName)),
+        ]), typescript_1.default.factory.createStringLiteral(importFromName)),
+    ];
+}
+function createTypeAlias({ exported, alias, typeParams, type, }) {
+    return typescript_1.default.factory.createTypeAliasDeclaration(constructModifiersArray({ exported }), alias, typeParams, type);
+}
+function createRequireNativeViewDeclaration(module, view) {
+    return [
+        createParameter({
+            modifiers: [constModifier()],
+            name: view.name,
+            initializer: createCall({
+                expression: 'requireNativeView',
+                typeArgs: [typescript_1.default.factory.createTypeReferenceNode(getViewPropsTypeName(view))],
+                args: [
+                    typescript_1.default.factory.createStringLiteral(module.name),
+                    typescript_1.default.factory.createStringLiteral(view.name),
+                ],
+            }),
+        }),
+    ];
+}
+function createExportAllDeclaration({ importFromName, justTypes, }) {
+    return [
+        typescript_1.default.factory.createExportDeclaration(undefined, justTypes ?? false, undefined, typescript_1.default.factory.createStringLiteral(importFromName)),
+    ];
+}
+function createExportDefault(name = '_default') {
+    return [typescript_1.default.factory.createExportDefault(typescript_1.default.factory.createIdentifier(name))];
+}
+function createComponentType(propsTypeName) {
+    return typescript_1.default.factory.createTypeReferenceNode('React.JSXElementConstructor', [
+        typescript_1.default.factory.createTypeReferenceNode(propsTypeName),
+    ]);
+}
+function getMissingTypeIdentifiers(fileTypeInformation) {
+    return fileTypeInformation.usedTypeIdentifiers
+        .difference(fileTypeInformation.declaredTypeIdentifiers)
+        .difference(getBasicTypesIdentifiers());
+}
+function buildPropsMembers({ props, events }) {
+    const buildEventPropertySignature = (eventDeclaration) => {
+        const name = eventDeclaration;
+        const typeNode = typescript_1.default.factory.createFunctionTypeNode(undefined, [createParameter({ name: 'event', type: anyKeywordType() })], voidKeywordType());
+        // TODO(@HubertBer) check whether we have ways of making events not optional
+        return createPropertySignature({ name, typeNode, optional: true });
+    };
+    const buildPropPropertySignature = (propDeclaration) => {
+        const propTypeArgument = propDeclaration.arguments[1]?.type;
+        if (!propDeclaration || !propDeclaration.arguments || !propTypeArgument) {
+            return undefined;
+        }
+        const name = propDeclaration.name;
+        const typeNode = mapTypeToTsTypeNode(propTypeArgument);
+        return createPropertySignature({ name, typeNode });
+    };
+    return [
+        ...props.map(buildPropPropertySignature).filter((p) => p),
+        ...events.map(buildEventPropertySignature),
+    ];
+}
+function buildViewPropsInterface(view, options) {
+    if (!view) {
+        return [];
+    }
+    return [
+        typescript_1.default.factory.createInterfaceDeclaration(constructModifiersArray(options), getViewPropsTypeName(view), undefined, [
+            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
+                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier('ViewProps'), undefined),
+            ]),
+        ], buildPropsMembers(view)),
+    ];
+}
+function buildClassProperty(declaration) {
+    return createProperty({
+        modifiers: [readonlyModifier()],
+        name: declaration.name,
+        typeNode: mapTypeToTsTypeNode(declaration.type),
+    });
+}
+function buildNativeModuleClassDeclaration({ moduleClassDeclaration, exportedModuleName, }) {
+    const buildClassTypeProperty = (classDeclaration) => createProperty({
+        // TODO(@HubertBer): that's a hack, but I couldn't find a proper way to do this
+        // The problem is that declare class semantics seem somewhat different than class semantics.
+        name: classDeclaration.name,
+        typeNode: typescript_1.default.factory.createTypeQueryNode(typescript_1.default.factory.createIdentifier(classDeclaration.name)),
+    });
+    const buildSyncMethod = (functionDeclaration) => buildFunction({
+        functionDeclaration,
+        method: true,
+        declaration: true,
+    });
+    const buildAsyncMethod = (functionDeclaration) => buildFunction({
+        functionDeclaration,
+        async: true,
+        method: true,
+        declaration: true,
+    });
+    return [
+        typescript_1.default.factory.createClassDeclaration([exportModifier(), declareModifier()], exportedModuleName ?? `${moduleClassDeclaration.name}NativeModuleType`, undefined, [
+            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
+                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier('NativeModule'), undefined),
+            ]),
+        ], [
+            ...moduleClassDeclaration.constants.map(buildClassProperty),
+            ...moduleClassDeclaration.properties.map(buildClassProperty),
+            ...moduleClassDeclaration.functions.map(buildSyncMethod),
+            ...moduleClassDeclaration.asyncFunctions.map(buildAsyncMethod),
+            ...moduleClassDeclaration.classes.map(buildClassTypeProperty),
+        ]),
+    ];
+}
+function buildArgumentDeclarationAndName(arg) {
+    const argName = arg.name ?? '_' + getNextFreeId();
+    const argDeclaration = createParameter({
+        name: argName,
+        type: mapTypeToTsTypeNode(arg.type),
+    });
+    return { argDeclaration, argName };
+}
+function buildArgumentDeclaration(arg) {
+    return buildArgumentDeclarationAndName(arg).argDeclaration;
+}
+function buildFunction({ functionDeclaration, async, method, exported, declaration, returnStatement, overrideArgumentDeclarations, omitReturnType, }) {
+    const functionModifiers = constructModifiersArray({ exported, async: async && !declaration });
+    const customReturn = !!returnStatement;
+    const bareReturnTypeNode = mapTypeToTsTypeNode(functionDeclaration.returnType);
+    const wrapWithPromiseType = (typeNode) => typescript_1.default.factory.createTypeReferenceNode('Promise', [typeNode]);
+    let returnTypeNode = async
+        ? wrapWithPromiseType(bareReturnTypeNode)
+        : bareReturnTypeNode;
+    if (omitReturnType) {
+        returnTypeNode = undefined;
+    }
+    const argumentDeclarations = overrideArgumentDeclarations ?? functionDeclaration.arguments.map(buildArgumentDeclaration);
+    if (method) {
+        return typescript_1.default.factory.createMethodDeclaration(functionModifiers, undefined, functionDeclaration.name, undefined, undefined, argumentDeclarations, returnTypeNode, declaration ? undefined : typescript_1.default.factory.createBlock(customReturn ? returnStatement : []));
+    }
+    return typescript_1.default.factory.createFunctionDeclaration(functionModifiers, undefined, functionDeclaration.name, undefined, argumentDeclarations, returnTypeNode, declaration ? undefined : typescript_1.default.factory.createBlock(customReturn ? returnStatement : []));
+}
+function buildConstructor(constructor, declaration) {
+    return typescript_1.default.factory.createConstructorDeclaration(undefined, constructor.arguments.map(buildArgumentDeclaration), declaration ? undefined : typescript_1.default.factory.createBlock([]));
+}
+// TODO(@HubertBer): figure out what about inheritance, should or should not inherit SharedObject
+function buildClass({ classDeclaration, exported, declaration, getFunctionReturnBlock, }) {
+    const getReturnStatement = (method) => !declaration && getFunctionReturnBlock ? getFunctionReturnBlock(method) : null;
+    const buildMethod = (method, async) => buildFunction({
+        functionDeclaration: method,
+        method: true,
+        async,
+        declaration,
+        returnStatement: getReturnStatement(method),
+    });
+    const classMembers = [
+        ...classDeclaration.methods.map((m) => buildMethod(m)),
+        ...classDeclaration.asyncMethods.map((m) => buildMethod(m, true)),
+        ...(declaration ? classDeclaration.properties.map(buildClassProperty) : []),
+        classDeclaration.constructor
+            ? buildConstructor(classDeclaration.constructor, declaration ?? false)
+            : undefined,
+    ].filter((x) => x !== undefined);
+    return typescript_1.default.factory.createClassDeclaration(constructModifiersArray({ exported, declare: declaration }), typescript_1.default.factory.createIdentifier(classDeclaration.name), undefined, [], classMembers);
+}
+function buildModuleDefaultExport({ moduleName, moduleType, declaration, }) {
+    const name = '_default';
+    const type = moduleType ? typescript_1.default.factory.createTypeReferenceNode(moduleType) : undefined;
+    return [
+        createParameter({
+            modifiers: [constModifier()],
+            name,
+            type,
+            initializer: declaration
+                ? undefined
+                : createRequireNativeModuleExpression({ moduleName, moduleType }),
+        }),
+        typescript_1.default.factory.createExportDefault(typescript_1.default.factory.createIdentifier('_default')),
+    ];
+}
+function buildUnknownTypeAlias(identifier, exported, inferredTypeParametersCount) {
+    const paramCount = inferredTypeParametersCount.get(identifier);
+    const typeParamsList = [];
+    for (let i = 0; i < (paramCount ?? 0); i += 1) {
+        typeParamsList.push(typescript_1.default.factory.createTypeParameterDeclaration(undefined, 'T' + i));
+    }
+    const typeParams = (paramCount ?? 0) === 0 ? undefined : typeParamsList;
+    return createTypeAlias({ exported, alias: identifier, type: unknownKeywordType(), typeParams });
+}
+function buildRecordTypeAlias(recordType, exported) {
+    return createTypeAlias({
+        exported,
+        alias: recordType.name,
+        type: typescript_1.default.factory.createTypeLiteralNode(recordType.fields.map((field) => {
+            const optional = field.type.kind === typeInformation_1.TypeKind.OPTIONAL;
+            const typeNode = mapTypeToTsTypeNode(optional ? field.type.type : field.type);
+            const name = field.name ?? '_' + getNextFreeId();
+            return createPropertySignature({ name, optional, typeNode });
+        })),
+    });
+}
+function buildEnumTypeDeclaration(enumType, exported, declared) {
+    return typescript_1.default.factory.createEnumDeclaration(constructModifiersArray({ exported, declare: declared }), enumType.name, enumType.cases.map((enumcase) => typescript_1.default.factory.createEnumMember(enumcase)));
+}
+function buildMissingTypesDeclarations(ctx) {
+    if (ctx.missingTypes.size === 0) {
+        return [];
+    }
+    const header = typescript_1.default.addSyntheticLeadingComment(typescript_1.default.factory.createIdentifier(''), typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` These types haven't been defined in provided file(s).`, true);
+    const aliases = [...ctx.missingTypes].map((identifier) => buildUnknownTypeAlias(identifier, true, ctx.fileInfo.inferredTypeParametersCount));
+    return [header, ...aliases];
+}
+function buildDefaultViewComponent({ componentName, propsTypeAlias, }) {
+    const jsxElement = typescript_1.default.factory.createJsxSelfClosingElement(typescript_1.default.factory.createIdentifier(componentName), undefined, typescript_1.default.factory.createJsxAttributes([
+        typescript_1.default.factory.createJsxSpreadAttribute(typescript_1.default.factory.createIdentifier('props')),
+    ]));
+    const functionBody = typescript_1.default.factory.createBlock([typescript_1.default.factory.createReturnStatement(jsxElement)]);
+    return [
+        typescript_1.default.factory.createFunctionExpression([exportModifier(), defaultModifier()], undefined, componentName + 'Component', undefined, [
+            createParameter({
+                name: 'props',
+                type: typescript_1.default.factory.createTypeReferenceNode(propsTypeAlias),
+            }),
+        ], undefined, functionBody),
+    ];
+}
+function buildExposedTypesDeclarations(ctx, options) {
+    const recordDeclarationMap = (recordType) => buildRecordTypeAlias(recordType, options.exported ?? false);
+    const enumDeclarationMap = (enumType) => buildEnumTypeDeclaration(enumType, options.exported ?? false, options.declare ?? false);
+    const classDeclarationMap = (classDeclaration) => buildClass({ classDeclaration, exported: true, declaration: true });
+    return joinTSNodesWithNewlines([
+        createImportDeclaration({ namedImportsNames: ['NativeModule'], importFromName: 'expo' }),
+        buildMissingTypesDeclarations(ctx),
+        ctx.fileInfo.records.flatMap(recordDeclarationMap),
+        ctx.fileInfo.enums.flatMap(enumDeclarationMap),
+        ctx.module.classes.map(classDeclarationMap),
+    ]);
+}
+function buildModuleDeclarationNodes(ctx) {
+    return joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        buildExposedTypesDeclarations(ctx, { exported: true }),
+        buildNativeModuleClassDeclaration({ moduleClassDeclaration: ctx.module }),
+        buildModuleDefaultExport({
+            moduleName: ctx.module.name,
+            moduleType: ctx.module.name,
+            declaration: true,
+        }),
+    ]);
+}
+function getViewPropsTypeName(view) {
+    return view.name + (view.name.endsWith('View') ? 'Props' : 'ViewProps');
+}
+function buildViewDeclarationNodes(ctx) {
+    if (!ctx.view) {
+        return [];
+    }
+    const viewComponentType = createComponentType(getViewPropsTypeName(ctx.view));
+    const modifiers = [declareModifier(), constModifier()];
+    return joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+        buildMissingTypesDeclarations(ctx),
+        buildViewPropsInterface(ctx.view, {}),
+        [createParameter({ modifiers, name: '_default', type: viewComponentType })],
+        createExportDefault(),
+    ]);
+}
+function buildJSXIntrinsicsViewNodes(ctx) {
+    const name = ctx.module.name;
+    const propsTypeNode = ctx.view
+        ? typescript_1.default.factory.createTypeLiteralNode(buildPropsMembers(ctx.view))
+        : undefined;
+    const jsxIntrinsicElementsNodes = [];
+    if (ctx.view) {
+        const globalIdentifier = typescript_1.default.factory.createIdentifier('global');
+        const jsxIdentifier = typescript_1.default.factory.createIdentifier('JSX');
+        const intrinsicElementsIdentifier = typescript_1.default.factory.createIdentifier('IntrinsicElements');
+        jsxIntrinsicElementsNodes.push(typescript_1.default.factory.createModuleDeclaration([declareModifier()], globalIdentifier, typescript_1.default.factory.createModuleBlock([
+            typescript_1.default.factory.createModuleDeclaration(undefined, jsxIdentifier, typescript_1.default.factory.createModuleBlock([
+                typescript_1.default.factory.createInterfaceDeclaration(undefined, intrinsicElementsIdentifier, undefined, undefined, [createPropertySignature({ name, typeNode: propsTypeNode })]),
+            ]), typescript_1.default.NodeFlags.Namespace),
+        ]), typescript_1.default.NodeFlags.GlobalAugmentation));
+    }
+    return joinTSNodesWithNewlines([
+        buildExposedTypesDeclarations(ctx, { declare: true }),
+        jsxIntrinsicElementsNodes,
+    ]);
+}
+function buildNativeModuleGeneratedNodes(ctx) {
+    return joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+        buildExposedTypesDeclarations(ctx, { exported: true }),
+        buildViewPropsInterface(ctx.view, { exported: true }),
+        buildNativeModuleClassDeclaration({ moduleClassDeclaration: ctx.module }),
+    ]);
+}
+function buildStableNativeModuleInterface(ctx) {
+    const generatedModuleAlias = ctx.module.name;
+    const generatedModuleTypeAlias = `${ctx.module.name}NativeModuleType`;
+    const generatedFilePath = `./${ctx.module.name}.generated`;
+    const exportedFunctionReturnStatement = (functionDeclaration, overrideArguments) => {
+        const expression = `${generatedModuleAlias}.${functionDeclaration.name}`;
+        const args = overrideArguments ??
+            functionDeclaration.arguments.map((arg) => typescript_1.default.factory.createIdentifier(arg.name ?? 'unnamedArgument'));
+        return typescript_1.default.factory.createReturnStatement(createCall({
+            expression,
+            args,
+        }));
+    };
+    const mapFunctionDeclarationTemplate = (isAsync) => (functionDeclaration) => {
+        const argumentDeclarations = [];
+        const argumentNames = [];
+        for (const arg of functionDeclaration.arguments) {
+            const { argDeclaration, argName } = buildArgumentDeclarationAndName(arg);
+            argumentDeclarations.push(argDeclaration);
+            argumentNames.push(argName);
+        }
+        return [
+            buildFunction({
+                functionDeclaration,
+                async: isAsync,
+                exported: true,
+                returnStatement: [
+                    exportedFunctionReturnStatement(functionDeclaration, argumentNames.map(typescript_1.default.factory.createIdentifier)),
+                ],
+                overrideArgumentDeclarations: argumentDeclarations,
+                omitReturnType: true,
+            }),
+        ];
+    };
+    const mapSyncFunctionDeclaration = mapFunctionDeclarationTemplate(false);
+    const mapAsyncFunctionDeclaration = mapFunctionDeclarationTemplate(true);
+    const buildConstantExportProperty = (constant) => {
+        const typeNode = mapTypeToTsTypeNode(constant.type);
+        const modifiers = [exportModifier(), constModifier()];
+        const initializer = typescript_1.default.factory.createIdentifier(`${generatedModuleAlias}.${constant.name}`);
+        return createProperty({ modifiers, name: constant.name, typeNode, initializer });
+    };
+    return joinTSNodesWithNewlines([
+        ctx.view
+            ? createImportDeclaration({ importFromName: 'react', defaultImportName: 'React' })
+            : [],
+        createImportDeclaration({
+            namedImportsNames: [
+                ...ctx.fileInfo.usedTypeIdentifiers.difference(getBasicTypesIdentifiers()),
+                ...[generatedModuleTypeAlias, ctx.view ? getViewPropsTypeName(ctx.view) : null].filter((v) => v !== null),
+            ],
+            importFromName: generatedFilePath,
+        }),
+        createImportDeclaration({
+            namedImportsNames: ['requireNativeModule', 'requireNativeView'],
+            importFromName: 'expo',
+        }),
+        [
+            createParameter({
+                modifiers: [constModifier()],
+                name: ctx.module.name,
+                type: typescript_1.default.factory.createTypeReferenceNode(generatedModuleTypeAlias),
+                initializer: createRequireNativeModuleExpression({
+                    moduleName: ctx.module.name,
+                    moduleType: generatedModuleTypeAlias,
+                }),
+            }),
+        ],
+        ctx.view ? createRequireNativeViewDeclaration(ctx.module, ctx.view) : [],
+        ctx.module.constants.map(buildConstantExportProperty),
+        ctx.module.functions.flatMap(mapSyncFunctionDeclaration),
+        ctx.module.asyncFunctions.flatMap(mapAsyncFunctionDeclaration),
+        ctx.view
+            ? buildDefaultViewComponent({
+                componentName: ctx.view.name,
+                propsTypeAlias: getViewPropsTypeName(ctx.view),
+            })
+            : [],
+    ]);
+}
+async function tsNodesToString(elements) {
+    const printer = typescript_1.default.createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed });
+    const resultFile = typescript_1.default.createSourceFile('', '', typescript_1.default.ScriptTarget.Latest, false, typescript_1.default.ScriptKind.TSX);
+    const viewTypes = typescript_1.default.factory.createNodeArray(elements);
+    const printedTs = printer.printList(typescript_1.default.ListFormat.MultiLine | typescript_1.default.ListFormat.PreserveLines, viewTypes, resultFile);
+    return await prettifyCode(printedTs, 'typescript');
+}
+async function prettifyCode(text, parser = 'babel') {
+    return await prettier_1.default.format(text, {
+        parser,
+        tabWidth: 2,
+        printWidth: 100,
+        trailingComma: 'none',
+        singleQuote: true,
+    });
+}
+async function generateViewTypesFileContent(fileTypeInformation) {
+    const ctx = createDefaultGenerationContext(fileTypeInformation);
+    if (!ctx) {
+        return null;
+    }
+    return tsNodesToString(buildViewDeclarationNodes(ctx));
+}
+async function generateJSXIntrinsicsFileContent(fileTypeInformation) {
+    const ctx = createDefaultGenerationContext(fileTypeInformation);
+    if (!ctx) {
+        return null;
+    }
+    return tsNodesToString(buildJSXIntrinsicsViewNodes(ctx));
+}
+async function generateModuleTypesFileContent(fileTypeInformation) {
+    const ctx = createDefaultGenerationContext(fileTypeInformation);
+    if (!ctx) {
+        return null;
+    }
+    return tsNodesToString(buildModuleDeclarationNodes(ctx));
+}
+async function generateConciseTsInterface(fileTypeInformation) {
+    const ctx = createDefaultGenerationContext(fileTypeInformation);
+    if (!ctx) {
+        return { volatileGeneratedFileContent: '', moduleTypescriptInterfaceFileContent: '' };
+    }
+    const volatileGeneratedFileContent = await tsNodesToString(buildNativeModuleGeneratedNodes(ctx));
+    const moduleTypescriptInterfaceFileContent = await tsNodesToString(buildStableNativeModuleInterface(ctx));
+    return {
+        volatileGeneratedFileContent,
+        moduleTypescriptInterfaceFileContent,
+    };
+}
+async function generateFullTsInterface(fileTypeInformation) {
+    const ctx = createDefaultGenerationContext(fileTypeInformation);
+    if (!ctx) {
+        return null;
+    }
+    const moduleNativeFileImportName = `${ctx?.module.name}Module`;
+    const moduleTypesFileImportName = `${ctx?.module.name}.types`;
+    const moduleViewsFilesImportNames = [];
+    const moduleTypesFileNodes = joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+        buildExposedTypesDeclarations(ctx, { exported: true }),
+        ...ctx.module.views.map((view) => buildViewPropsInterface(view, { exported: true })),
+    ]);
+    const moduleViewFilesNodes = [];
+    for (const view of ctx.module.views) {
+        const moduleViewFileNodes = joinTSNodesWithNewlines([
+            createGeneratedPrefix(),
+            createImportDeclaration({
+                namedImportsNames: ['requireNativeView'],
+                importFromName: 'expo',
+            }),
+            createImportDeclaration({
+                namedImportsNames: [getViewPropsTypeName(view)],
+                importFromName: `./${moduleTypesFileImportName}`,
+            }),
+            createRequireNativeViewDeclaration(ctx.module, view),
+            buildDefaultViewComponent({
+                componentName: view.name,
+                propsTypeAlias: getViewPropsTypeName(view),
+            }),
+        ]);
+        moduleViewFilesNodes.push(moduleViewFileNodes);
+        moduleViewsFilesImportNames.push(`${view.name}View`);
+    }
+    const moduleNativeModuleNodes = joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        createImportDeclaration({
+            namedImportsNames: ['requireNativeModule', 'NativeModule'],
+            importFromName: 'expo',
+        }),
+        createImportDeclaration({
+            namedImportsNames: [...getAllNonBasicTypes(ctx.fileInfo)],
+            importFromName: `./${moduleTypesFileImportName}`,
+        }),
+        buildNativeModuleClassDeclaration({
+            moduleClassDeclaration: ctx.module,
+            exportedModuleName: ctx.module.name,
+        }),
+        buildModuleDefaultExport({ moduleName: ctx.module.name, moduleType: ctx.module.name }),
+    ]);
+    const indexFileNodes = joinTSNodesWithNewlines([
+        createGeneratedPrefix(),
+        createExportAllDeclaration({
+            importFromName: `./${moduleTypesFileImportName}`,
+            justTypes: true,
+        }),
+        createExportDefaultAsDeclaration({
+            exportAsName: ctx.module.name,
+            importFromName: `./${moduleNativeFileImportName}`,
+        }),
+        ...ctx.module.views.map((view, idx) => createExportDefaultAsDeclaration({
+            exportAsName: view.name,
+            importFromName: `./${moduleViewsFilesImportNames[idx]}`,
+        })),
+    ]);
+    const [moduleTypesFileContent, moduleViewFilesContents, moduleNativeFileContent, indexFileContent,] = await Promise.all([
+        tsNodesToString(moduleTypesFileNodes),
+        Promise.all(moduleViewFilesNodes.map(tsNodesToString)),
+        tsNodesToString(moduleNativeModuleNodes),
+        tsNodesToString(indexFileNodes),
+    ]);
+    const moduleTypesFile = {
+        content: moduleTypesFileContent,
+        name: `${moduleTypesFileImportName}.ts`,
+    };
+    const moduleViewsFiles = moduleViewFilesContents.map((moduleViewFileContent, idx) => {
+        return {
+            content: moduleViewFileContent,
+            name: `${moduleViewsFilesImportNames[idx]}.tsx`,
+        };
+    });
+    const moduleNativeFile = {
+        content: moduleNativeFileContent,
+        name: `${moduleNativeFileImportName}.ts`,
+    };
+    const indexFile = { content: indexFileContent, name: `index.ts` };
+    return {
+        moduleTypesFile,
+        moduleViewsFiles,
+        moduleNativeFile,
+        indexFile,
+    };
+}
+//# sourceMappingURL=typescriptGeneration.js.map