@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/library/lib/enable-strict-type-checking.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLibraryStrictDefault = exports.enableStrictTypeChecking = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Enable Strict Mode in the library and spec TS Config
+ * */
+function enableStrictTypeChecking(host, options) {
+    updateTsConfig(host, options);
+}
+exports.enableStrictTypeChecking = enableStrictTypeChecking;
+function setLibraryStrictDefault(host, isStrict) {
+    // set the default so future libraries use it
+    // unless the user has previously set this value
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    nxJson.generators = nxJson.generators || {};
+    nxJson.generators['@nx/angular:library'] =
+        nxJson.generators['@nx/angular:library'] || {};
+    nxJson.generators['@nx/angular:library'].strict =
+        nxJson.generators['@nx/angular:library'].strict ?? isStrict;
+    (0, devkit_1.updateNxJson)(host, nxJson);
+}
+exports.setLibraryStrictDefault = setLibraryStrictDefault;
+function updateTsConfig(host, options) {
+    // Update the settings in the tsconfig.app.json to enable strict type checking.
+    // This matches the settings defined by the Angular CL https://angular.io/guide/strict-mode
+    (0, devkit_1.updateJson)(host, `${options.projectRoot}/tsconfig.json`, (json) => {
+        // update the TypeScript settings
+        json.compilerOptions = {
+            ...(json.compilerOptions ?? {}),
+            forceConsistentCasingInFileNames: true,
+            strict: true,
+            noImplicitOverride: true,
+            noPropertyAccessFromIndexSignature: true,
+            noImplicitReturns: true,
+            noFallthroughCasesInSwitch: true,
+        };
+        // update Angular Template Settings
+        json.angularCompilerOptions = {
+            ...(json.angularCompilerOptions ?? {}),
+            enableI18nLegacyMessageIdFormat: false,
+            strictInjectionParameters: true,
+            strictInputAccessModifiers: true,
+            strictTemplates: true,
+        };
+        return json;
+    });
+}

package/src/generators/library/lib/normalize-options.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+import { NormalizedSchema } from './normalized-schema';
+export declare function normalizeOptions(host: Tree, schema: Schema): Promise<NormalizedSchema>;

package/src/generators/library/lib/normalize-options.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const eslint_1 = require("@nx/eslint");
+const test_runners_1 = require("../../../utils/test-runners");
+async function normalizeOptions(host, schema) {
+    schema.standalone = schema.standalone ?? true;
+    // Create a schema with populated default values
+    const options = {
+        buildable: false,
+        linter: eslint_1.Linter.EsLint,
+        publishable: false,
+        simpleName: false,
+        skipFormat: false,
+        unitTestRunner: test_runners_1.UnitTestRunner.Jest,
+        // Publishable libs cannot use `full` yet, so if its false then use the passed value or default to `full`
+        compilationMode: schema.publishable
+            ? 'partial'
+            : schema.compilationMode ?? 'full',
+        skipModule: schema.skipModule || schema.standalone,
+        ...schema,
+    };
+    const { projectName, names: projectNames, projectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/angular:library',
+    });
+    const fileName = options.simpleName
+        ? projectNames.projectSimpleName
+        : projectNames.projectFileName;
+    const moduleName = `${(0, devkit_1.names)(fileName).className}Module`;
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    const modulePath = `${projectRoot}/src/lib/${fileName}.module.ts`;
+    const ngCliSchematicLibRoot = projectName;
+    const allNormalizedOptions = {
+        ...options,
+        linter: options.linter ?? eslint_1.Linter.EsLint,
+        unitTestRunner: options.unitTestRunner ?? test_runners_1.UnitTestRunner.Jest,
+        prefix: options.prefix ?? 'lib',
+        name: projectName,
+        projectRoot,
+        entryFile: 'index',
+        moduleName,
+        modulePath,
+        parsedTags,
+        fileName,
+        importPath,
+        ngCliSchematicLibRoot,
+        standaloneComponentName: `${(0, devkit_1.names)(projectNames.projectSimpleName).className}Component`,
+    };
+    const { displayBlock, inlineStyle, inlineTemplate, viewEncapsulation, changeDetection, style, skipTests, selector, skipSelector, flat, ...libraryOptions } = allNormalizedOptions;
+    return {
+        libraryOptions,
+        componentOptions: {
+            name: fileName,
+            standalone: libraryOptions.standalone,
+            displayBlock,
+            inlineStyle,
+            inlineTemplate,
+            viewEncapsulation,
+            changeDetection,
+            style,
+            skipTests,
+            selector,
+            skipSelector,
+            flat,
+        },
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/library/lib/normalized-schema.d.ts

@@ -0,0 +1,55 @@
+import { UnitTestRunner } from '../../../utils/test-runners';
+import type { Linter } from '@nx/eslint';
+export interface NormalizedSchema {
+    libraryOptions: {
+        name: string;
+        addTailwind?: boolean;
+        skipFormat?: boolean;
+        simpleName?: boolean;
+        addModuleSpec?: boolean;
+        directory?: string;
+        sourceDir?: string;
+        buildable?: boolean;
+        publishable?: boolean;
+        importPath?: string;
+        standaloneConfig?: boolean;
+        spec?: boolean;
+        commonModule?: boolean;
+        routing?: boolean;
+        lazy?: boolean;
+        parent?: string;
+        tags?: string;
+        strict?: boolean;
+        compilationMode?: 'full' | 'partial';
+        setParserOptionsProject?: boolean;
+        skipModule?: boolean;
+        skipPackageJson?: boolean;
+        skipPostInstall?: boolean;
+        standalone?: boolean;
+        linter: Linter;
+        unitTestRunner: UnitTestRunner;
+        prefix: string;
+        fileName: string;
+        projectRoot: string;
+        entryFile: string;
+        modulePath: string;
+        moduleName: string;
+        parsedTags: string[];
+        ngCliSchematicLibRoot: string;
+        standaloneComponentName: string;
+    };
+    componentOptions: {
+        name: string;
+        standalone?: boolean;
+        displayBlock?: boolean;
+        inlineStyle?: boolean;
+        inlineTemplate?: boolean;
+        viewEncapsulation?: 'Emulated' | 'None' | 'ShadowDom';
+        changeDetection?: 'Default' | 'OnPush';
+        style?: 'css' | 'scss' | 'sass' | 'less' | 'none';
+        skipTests?: boolean;
+        selector?: string;
+        skipSelector?: boolean;
+        flat?: boolean;
+    };
+}

package/src/generators/library/lib/normalized-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/generators/library/lib/set-generator-defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function setGeneratorDefaults(tree: Tree, options: NormalizedSchema): void;

package/src/generators/library/lib/set-generator-defaults.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setGeneratorDefaults = void 0;
+const devkit_1 = require("@nx/devkit");
+function setGeneratorDefaults(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.generators = nxJson.generators ?? {};
+    nxJson.generators['@nx/angular:library'] = {
+        linter: options.libraryOptions.linter,
+        unitTestRunner: options.libraryOptions.unitTestRunner,
+        ...(nxJson.generators['@nx/angular:library'] || {}),
+    };
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.setGeneratorDefaults = setGeneratorDefaults;

package/src/generators/library/lib/update-lib-package-npm-scope.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema } from './normalized-schema';
+export declare function updateLibPackageNpmScope(host: Tree, options: NormalizedSchema['libraryOptions']): void;

package/src/generators/library/lib/update-lib-package-npm-scope.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateLibPackageNpmScope = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateLibPackageNpmScope(host, options) {
+    return (0, devkit_1.updateJson)(host, `${options.projectRoot}/package.json`, (json) => {
+        json.name = options.importPath;
+        return json;
+    });
+}
+exports.updateLibPackageNpmScope = updateLibPackageNpmScope;

package/src/generators/library/lib/update-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import { NormalizedSchema } from './normalized-schema';
+export declare function updateTsConfig(host: Tree, options: NormalizedSchema['libraryOptions']): void;

package/src/generators/library/lib/update-tsconfig.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const update_project_root_tsconfig_1 = require("../../utils/update-project-root-tsconfig");
+function updateProjectConfig(host, options) {
+    (0, devkit_1.updateJson)(host, `${options.projectRoot}/tsconfig.lib.json`, (json) => {
+        json.include = ['src/**/*.ts'];
+        json.exclude = [
+            ...new Set([
+                ...(json.exclude || []),
+                'jest.config.ts',
+                'src/**/*.test.ts',
+                'src/**/*.spec.ts',
+            ]),
+        ];
+        return json;
+    });
+    // tsconfig.json
+    (0, update_project_root_tsconfig_1.updateProjectRootTsConfig)(host, options.projectRoot, (0, js_1.getRelativePathToRootTsConfig)(host, options.projectRoot));
+}
+function updateProjectIvyConfig(host, options) {
+    if (options.buildable || options.publishable) {
+        return (0, devkit_1.updateJson)(host, `${options.projectRoot}/tsconfig.lib.prod.json`, (json) => {
+            json.angularCompilerOptions['compilationMode'] =
+                options.compilationMode === 'full' ? undefined : 'partial';
+            return json;
+        });
+    }
+}
+function updateTsConfig(host, options) {
+    (0, update_project_root_tsconfig_1.extractTsConfigBase)(host);
+    updateProjectConfig(host, options);
+    updateProjectIvyConfig(host, options);
+}
+exports.updateTsConfig = updateTsConfig;

package/src/generators/library/library.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function libraryGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function libraryGeneratorInternal(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default libraryGenerator;

package/src/generators/library/library.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.libraryGeneratorInternal = exports.libraryGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const js_1 = require("@nx/js");
+const init_1 = require("../../generators/init/init");
+const add_linting_1 = require("../add-linting/add-linting");
+const setup_tailwind_1 = require("../setup-tailwind/setup-tailwind");
+const version_utils_1 = require("../utils/version-utils");
+const dependencies_1 = require("../utils/dependencies");
+const add_module_1 = require("./lib/add-module");
+const add_standalone_component_1 = require("./lib/add-standalone-component");
+const enable_strict_type_checking_1 = require("./lib/enable-strict-type-checking");
+const normalize_options_1 = require("./lib/normalize-options");
+const update_lib_package_npm_scope_1 = require("./lib/update-lib-package-npm-scope");
+const update_tsconfig_1 = require("./lib/update-tsconfig");
+const create_files_1 = require("./lib/create-files");
+const add_project_1 = require("./lib/add-project");
+const add_jest_1 = require("../utils/add-jest");
+const set_generator_defaults_1 = require("./lib/set-generator-defaults");
+const ensure_angular_dependencies_1 = require("../utils/ensure-angular-dependencies");
+const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
+async function libraryGenerator(tree, schema) {
+    return await libraryGeneratorInternal(tree, {
+        // provide a default projectNameAndRootFormat to avoid breaking changes
+        // to external generators invoking this one
+        projectNameAndRootFormat: 'derived',
+        ...schema,
+    });
+}
+exports.libraryGenerator = libraryGenerator;
+async function libraryGeneratorInternal(tree, schema) {
+    // Do some validation checks
+    if (!schema.routing && schema.lazy) {
+        throw new Error(`To use "--lazy" option, "--routing" must also be set.`);
+    }
+    if (schema.publishable === true && !schema.importPath) {
+        throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
+    }
+    if (schema.addTailwind && !schema.buildable && !schema.publishable) {
+        throw new Error(`To use "--addTailwind" option, you have to set either "--buildable" or "--publishable".`);
+    }
+    const options = await (0, normalize_options_1.normalizeOptions)(tree, schema);
+    const { libraryOptions } = options;
+    const pkgVersions = (0, version_utils_1.versions)(tree);
+    await (0, js_1.initGenerator)(tree, { ...options, js: false, skipFormat: true });
+    await (0, init_1.default)(tree, { ...libraryOptions, skipFormat: true });
+    (0, ensure_angular_dependencies_1.ensureAngularDependencies)(tree);
+    const project = (0, add_project_1.addProject)(tree, libraryOptions);
+    (0, create_files_1.createFiles)(tree, options, project);
+    (0, update_tsconfig_1.updateTsConfig)(tree, libraryOptions);
+    await addUnitTestRunner(tree, libraryOptions);
+    updateNpmScopeIfBuildableOrPublishable(tree, libraryOptions);
+    (0, set_generator_defaults_1.setGeneratorDefaults)(tree, options);
+    if (!libraryOptions.standalone) {
+        (0, add_module_1.addModule)(tree, libraryOptions);
+    }
+    else {
+        await (0, add_standalone_component_1.addStandaloneComponent)(tree, options);
+    }
+    setStrictMode(tree, libraryOptions);
+    await addLinting(tree, libraryOptions);
+    if (libraryOptions.addTailwind) {
+        await (0, setup_tailwind_1.default)(tree, {
+            project: libraryOptions.name,
+            skipFormat: true,
+        });
+    }
+    if (libraryOptions.buildable || libraryOptions.publishable) {
+        (0, version_utils_1.addDependenciesToPackageJsonIfDontExist)(tree, {}, {
+            'ng-packagr': pkgVersions.ngPackagrVersion,
+        });
+        (0, dependencies_1.addBuildableLibrariesPostCssDependencies)(tree);
+    }
+    (0, js_1.addTsConfigPath)(tree, libraryOptions.importPath, [
+        (0, devkit_1.joinPathFragments)(libraryOptions.projectRoot, './src', 'index.ts'),
+    ]);
+    if (!libraryOptions.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return () => {
+        (0, devkit_1.installPackagesTask)(tree);
+        (0, log_show_project_command_1.logShowProjectCommand)(libraryOptions.name);
+    };
+}
+exports.libraryGeneratorInternal = libraryGeneratorInternal;
+async function addUnitTestRunner(host, options) {
+    if (options.unitTestRunner === 'jest') {
+        await (0, add_jest_1.addJest)(host, {
+            name: options.name,
+            projectRoot: options.projectRoot,
+            skipPackageJson: options.skipPackageJson,
+            strict: options.strict,
+        });
+    }
+}
+function updateNpmScopeIfBuildableOrPublishable(host, options) {
+    if (options.buildable || options.publishable) {
+        (0, update_lib_package_npm_scope_1.updateLibPackageNpmScope)(host, options);
+    }
+}
+function setStrictMode(host, options) {
+    if (options.strict) {
+        (0, enable_strict_type_checking_1.enableStrictTypeChecking)(host, options);
+    }
+    else {
+        (0, enable_strict_type_checking_1.setLibraryStrictDefault)(host, options.strict);
+    }
+}
+async function addLinting(host, options) {
+    if (options.linter === eslint_1.Linter.None) {
+        return;
+    }
+    await (0, add_linting_1.default)(host, {
+        projectName: options.name,
+        projectRoot: options.projectRoot,
+        prefix: options.prefix,
+        unitTestRunner: options.unitTestRunner,
+        setParserOptionsProject: options.setParserOptionsProject,
+        skipFormat: true,
+        skipPackageJson: options.skipPackageJson,
+    });
+}
+exports.default = libraryGenerator;

package/src/generators/library/schema.d.ts

@@ -0,0 +1,44 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+import type { UnitTestRunner } from '../../utils/test-runners';
+
+export interface Schema {
+  name: string;
+  addTailwind?: boolean;
+  skipFormat?: boolean;
+  simpleName?: boolean;
+  addModuleSpec?: boolean;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  sourceDir?: string;
+  buildable?: boolean;
+  publishable?: boolean;
+  importPath?: string;
+  standaloneConfig?: boolean;
+  spec?: boolean;
+  flat?: boolean;
+  commonModule?: boolean;
+  prefix?: string;
+  routing?: boolean;
+  lazy?: boolean;
+  parent?: string;
+  tags?: string;
+  strict?: boolean;
+  linter?: Linter;
+  unitTestRunner?: UnitTestRunner;
+  compilationMode?: 'full' | 'partial';
+  setParserOptionsProject?: boolean;
+  skipModule?: boolean;
+  skipPackageJson?: boolean;
+  standalone?: boolean;
+  displayBlock?: boolean;
+  inlineStyle?: boolean;
+  inlineTemplate?: boolean;
+  viewEncapsulation?: 'Emulated' | 'None' | 'ShadowDom';
+  changeDetection?: 'Default' | 'OnPush';
+  style?: 'css' | 'scss' | 'sass' | 'less' | 'none';
+  skipTests?: boolean;
+  selector?: string;
+  skipSelector?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/library/schema.json

@@ -0,0 +1,208 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "GeneratorAngularLibrary",
+  "title": "Create a library",
+  "description": "Creates an Angular library.",
+  "type": "object",
+  "cli": "nx",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the library.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the library?",
+      "pattern": "(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the library is placed.",
+      "x-priority": "important"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "publishable": {
+      "type": "boolean",
+      "default": false,
+      "description": "Generate a publishable library.",
+      "x-priority": "important"
+    },
+    "buildable": {
+      "type": "boolean",
+      "default": false,
+      "description": "Generate a buildable library.",
+      "x-priority": "important"
+    },
+    "prefix": {
+      "type": "string",
+      "format": "html-selector",
+      "description": "The prefix to apply to generated selectors.",
+      "alias": "p"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "simpleName": {
+      "description": "Don't include the directory in the name of the module or standalone component entry of the library.",
+      "type": "boolean",
+      "default": false
+    },
+    "addModuleSpec": {
+      "description": "Add a module spec file.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "skipTsConfig": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not update `tsconfig.json` for development experience."
+    },
+    "routing": {
+      "type": "boolean",
+      "default": false,
+      "description": "Add router configuration. See `lazy` for more information.",
+      "x-priority": "important"
+    },
+    "lazy": {
+      "type": "boolean",
+      "default": false,
+      "description": "Add `RouterModule.forChild` when set to true, and a simple array of routes when set to false.",
+      "x-priority": "important"
+    },
+    "parent": {
+      "type": "string",
+      "description": "Path to the parent route configuration using `loadChildren` or `children`, depending on what `lazy` is set to.",
+      "x-priority": "important"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the library (used for linting)."
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "default": "jest"
+    },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used to import it, like `@myorg/my-awesome-lib`. Must be a valid npm name."
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "Create a library with stricter type checking and build optimization options.",
+      "default": true
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "standaloneConfig": {
+      "description": "Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.",
+      "type": "boolean",
+      "default": true,
+      "x-deprecated": "Nx only supports standaloneConfig"
+    },
+    "compilationMode": {
+      "description": "Specifies the compilation mode to use. If not specified, it will default to `partial` for publishable libraries and to `full` for buildable libraries. The `full` value can not be used for publishable libraries.",
+      "type": "string",
+      "enum": ["full", "partial"]
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "addTailwind": {
+      "type": "boolean",
+      "description": "Whether to configure Tailwind CSS for the application. It can only be used with buildable and publishable libraries. Non-buildable libraries will use the application's Tailwind configuration.",
+      "default": false
+    },
+    "skipModule": {
+      "type": "boolean",
+      "description": "Whether to skip the creation of a default module when generating the library.",
+      "default": false
+    },
+    "standalone": {
+      "type": "boolean",
+      "description": "Generate a library that uses a standalone component instead of a module as the entry point.",
+      "default": true
+    },
+    "displayBlock": {
+      "description": "Specifies if the component generated style will contain `:host { display: block; }`. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "type": "boolean",
+      "default": false,
+      "alias": "b"
+    },
+    "inlineStyle": {
+      "description": "Include styles inline in the component.ts file. Only CSS styles can be included inline. By default, an external styles file is created and referenced in the component.ts file. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "type": "boolean",
+      "default": false,
+      "alias": "s"
+    },
+    "inlineTemplate": {
+      "description": "Include template inline in the component.ts file. By default, an external template file is created and referenced in the component.ts file. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "type": "boolean",
+      "default": false,
+      "alias": "t"
+    },
+    "viewEncapsulation": {
+      "description": "The view encapsulation strategy to use in the new component. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "enum": ["Emulated", "None", "ShadowDom"],
+      "type": "string",
+      "alias": "v"
+    },
+    "changeDetection": {
+      "description": "The change detection strategy to use in the new component. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "enum": ["Default", "OnPush"],
+      "type": "string",
+      "default": "Default",
+      "alias": "c"
+    },
+    "style": {
+      "description": "The file extension or preprocessor to use for style files, or `none` to skip generating the style file. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "type": "string",
+      "default": "css",
+      "enum": ["css", "scss", "sass", "less", "none"]
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Do not create `spec.ts` test files for the new component. Disclaimer: This option is only valid when `--standalone` is set to `true`.",
+      "default": false
+    },
+    "selector": {
+      "type": "string",
+      "format": "html-selector",
+      "description": "The HTML selector to use for this component. Disclaimer: This option is only valid when `--standalone` is set to `true`."
+    },
+    "skipSelector": {
+      "type": "boolean",
+      "default": false,
+      "description": "Specifies if the component should have a selector or not. Disclaimer: This option is only valid when `--standalone` is set to `true`."
+    },
+    "flat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Ensure the generated standalone component is not placed in a subdirectory. Disclaimer: This option is only valid when `--standalone` is set to `true`."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"],
+  "examplesFile": "../../../docs/library-examples.md"
+}

package/src/generators/library-secondary-entry-point/files/README.md__tmpl__

@@ -0,0 +1,3 @@
+# <%= secondaryEntryPoint %>
+
+Secondary entry point of `<%= mainEntryPoint %>`. It can be used by importing from `<%= secondaryEntryPoint %>`.