@nguniversal/express-engine/schematics/utils/utils.mjs

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { SchematicsException } from '@angular-devkit/schematics';
import { readWorkspace } from '@schematics/angular/utility';
import * as ts from 'typescript';
export async function getProject(host, projectName) {
    const workspace = await readWorkspace(host);
    const project = workspace.projects.get(projectName);
    if (!project || project.extensions.projectType !== 'application') {
        throw new SchematicsException(`Universal requires a project type of 'application'.`);
    }
    return project;
}
export function stripTsExtension(file) {
    return file.replace(/\.ts$/, '');
}
export async function getOutputPath(host, projectName, target) {
    // Generate new output paths
    const project = await getProject(host, projectName);
    const serverTarget = project.targets.get(target);
    if (!serverTarget || !serverTarget.options) {
        throw new SchematicsException(`Cannot find 'options' for ${projectName} ${target} target.`);
    }
    const { outputPath } = serverTarget.options;
    if (typeof outputPath !== 'string') {
        throw new SchematicsException(`outputPath for ${projectName} ${target} target is not a string.`);
    }
    return outputPath;
}
export function findImport(sourceFile, moduleName, symbolName) {
    // Only look through the top-level imports.
    for (const node of sourceFile.statements) {
        if (!ts.isImportDeclaration(node) ||
            !ts.isStringLiteral(node.moduleSpecifier) ||
            node.moduleSpecifier.text !== moduleName) {
            continue;
        }
        const namedBindings = node.importClause && node.importClause.namedBindings;
        if (!namedBindings || !ts.isNamedImports(namedBindings)) {
            continue;
        }
        if (namedBindings.elements.some((element) => element.name.text === symbolName)) {
            return namedBindings;
        }
    }
    return null;
}
/** Gets import information about the specified identifier by using the Type checker. */
export function getImportOfIdentifier(typeChecker, node) {
    const symbol = typeChecker.getSymbolAtLocation(node);
    if (!symbol || !symbol.declarations.length) {
        return null;
    }
    const decl = symbol.declarations[0];
    if (!ts.isImportSpecifier(decl)) {
        return null;
    }
    const importDecl = decl.parent.parent.parent;
    if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
        return null;
    }
    return {
        // Handles aliased imports: e.g. "import {Component as myComp} from ...";
        name: decl.propertyName ? decl.propertyName.text : decl.name.text,
        importModule: importDecl.moduleSpecifier.text,
        node: importDecl,
    };
}
export function addInitialNavigation(node) {
    const existingOptions = node.arguments[1];
    // If the user has explicitly set initialNavigation, we respect that
    if (existingOptions &&
        existingOptions.properties.some((exp) => ts.isPropertyAssignment(exp) &&
            ts.isIdentifier(exp.name) &&
            exp.name.text === 'initialNavigation')) {
        return node;
    }
    const enabledLiteral = ts.factory.createStringLiteral('enabledBlocking');
    // TypeScript will emit the Node with double quotes.
    // In schematics we usually write code with a single quotes
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    enabledLiteral.singleQuote = true;
    const initialNavigationProperty = ts.factory.createPropertyAssignment('initialNavigation', enabledLiteral);
    const routerOptions = existingOptions
        ? ts.factory.updateObjectLiteralExpression(existingOptions, ts.factory.createNodeArray([...existingOptions.properties, initialNavigationProperty]))
        : ts.factory.createObjectLiteralExpression([initialNavigationProperty], true);
    const args = [node.arguments[0], routerOptions];
    return ts.factory.createCallExpression(node.expression, node.typeArguments, args);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../modules/express-engine/schematics/utils/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { workspaces } from '@angular-devkit/core';\nimport { SchematicsException } from '@angular-devkit/schematics';\nimport { Tree } from '@angular-devkit/schematics/src/tree/interface';\nimport { readWorkspace } from '@schematics/angular/utility';\nimport * as ts from 'typescript';\n\nexport async function getProject(\n  host: Tree,\n  projectName: string,\n): Promise<workspaces.ProjectDefinition> {\n  const workspace = await readWorkspace(host);\n  const project = workspace.projects.get(projectName);\n\n  if (!project || project.extensions.projectType !== 'application') {\n    throw new SchematicsException(`Universal requires a project type of 'application'.`);\n  }\n\n  return project;\n}\n\nexport function stripTsExtension(file: string): string {\n  return file.replace(/\\.ts$/, '');\n}\n\nexport async function getOutputPath(\n  host: Tree,\n  projectName: string,\n  target: 'server' | 'build',\n): Promise<string> {\n  // Generate new output paths\n  const project = await getProject(host, projectName);\n  const serverTarget = project.targets.get(target);\n  if (!serverTarget || !serverTarget.options) {\n    throw new SchematicsException(`Cannot find 'options' for ${projectName} ${target} target.`);\n  }\n\n  const { outputPath } = serverTarget.options;\n  if (typeof outputPath !== 'string') {\n    throw new SchematicsException(\n      `outputPath for ${projectName} ${target} target is not a string.`,\n    );\n  }\n\n  return outputPath;\n}\n\nexport function findImport(\n  sourceFile: ts.SourceFile,\n  moduleName: string,\n  symbolName: string,\n): ts.NamedImports | null {\n  // Only look through the top-level imports.\n  for (const node of sourceFile.statements) {\n    if (\n      !ts.isImportDeclaration(node) ||\n      !ts.isStringLiteral(node.moduleSpecifier) ||\n      node.moduleSpecifier.text !== moduleName\n    ) {\n      continue;\n    }\n\n    const namedBindings = node.importClause && node.importClause.namedBindings;\n\n    if (!namedBindings || !ts.isNamedImports(namedBindings)) {\n      continue;\n    }\n\n    if (namedBindings.elements.some((element) => element.name.text === symbolName)) {\n      return namedBindings;\n    }\n  }\n\n  return null;\n}\n\nexport type Import = {\n  name: string;\n  importModule: string;\n  node: ts.ImportDeclaration;\n};\n\n/** Gets import information about the specified identifier by using the Type checker. */\nexport function getImportOfIdentifier(\n  typeChecker: ts.TypeChecker,\n  node: ts.Identifier,\n): Import | null {\n  const symbol = typeChecker.getSymbolAtLocation(node);\n\n  if (!symbol || !symbol.declarations.length) {\n    return null;\n  }\n\n  const decl = symbol.declarations[0];\n\n  if (!ts.isImportSpecifier(decl)) {\n    return null;\n  }\n\n  const importDecl = decl.parent.parent.parent;\n\n  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {\n    return null;\n  }\n\n  return {\n    // Handles aliased imports: e.g. \"import {Component as myComp} from ...\";\n    name: decl.propertyName ? decl.propertyName.text : decl.name.text,\n    importModule: importDecl.moduleSpecifier.text,\n    node: importDecl,\n  };\n}\n\nexport function addInitialNavigation(node: ts.CallExpression): ts.CallExpression {\n  const existingOptions = node.arguments[1] as ts.ObjectLiteralExpression | undefined;\n\n  // If the user has explicitly set initialNavigation, we respect that\n  if (\n    existingOptions &&\n    existingOptions.properties.some(\n      (exp) =>\n        ts.isPropertyAssignment(exp) &&\n        ts.isIdentifier(exp.name) &&\n        exp.name.text === 'initialNavigation',\n    )\n  ) {\n    return node;\n  }\n\n  const enabledLiteral = ts.factory.createStringLiteral('enabledBlocking');\n  // TypeScript will emit the Node with double quotes.\n  // In schematics we usually write code with a single quotes\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (enabledLiteral as any).singleQuote = true;\n\n  const initialNavigationProperty = ts.factory.createPropertyAssignment(\n    'initialNavigation',\n    enabledLiteral,\n  );\n  const routerOptions = existingOptions\n    ? ts.factory.updateObjectLiteralExpression(\n        existingOptions,\n        ts.factory.createNodeArray([...existingOptions.properties, initialNavigationProperty]),\n      )\n    : ts.factory.createObjectLiteralExpression([initialNavigationProperty], true);\n  const args = [node.arguments[0], routerOptions];\n\n  return ts.factory.createCallExpression(node.expression, node.typeArguments, args);\n}\n"]}