@ngxs/store 3.8.2-dev.master-09bece1 → 3.8.2-dev.master-b0e24dd

package/internals/testing/ngxs.setup.d.ts

@@ -1,7 +0,0 @@
-import { NgxsOptionsTesting, NgxsTesting } from './symbol';
-export declare class NgxsTestBed {
-    static configureTestingStates(options: NgxsOptionsTesting): NgxsTesting;
-    private static ngxsBootstrap;
-    private static resetTestBed;
-    private static createRootNode;
-}

package/internals/testing/skip-console-logging.d.ts

@@ -1 +0,0 @@
-export declare function skipConsoleLogging<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;

package/internals/testing/symbol.d.ts

@@ -1,14 +0,0 @@
-import { NgxsModuleOptions, Store } from '@ngxs/store';
-import { ModuleWithProviders } from '@angular/core';
-import { TestBedStatic } from '@angular/core/testing';
-import { ɵStateClass } from '@ngxs/store/internals';
-export interface NgxsOptionsTesting {
-    states?: ɵStateClass[];
-    ngxsOptions?: NgxsModuleOptions;
-    imports?: ModuleWithProviders<any>[];
-    before?: () => void;
-}
-export interface NgxsTesting {
-    store: Store;
-    getTestBed: TestBedStatic;
-}

package/operators/append.d.ts

@@ -1,5 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-/**
- * @param items - Specific items to append to the end of an array
- */
-export declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;

package/operators/compose.d.ts

@@ -1,2 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-export declare function compose<T>(...operators: NoInfer<StateOperator<T>[]>): StateOperator<T>;

package/operators/iif.d.ts

@@ -1,10 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-import { Predicate } from './utils';
-/**
- * @param condition - Condition can be a plain boolean value or a function,
- * that returns boolean, also this function can take a value as an argument
- * to which this state operator applies
- * @param trueOperatorOrValue - Any value or a state operator
- * @param elseOperatorOrValue - Any value or a state operator
- */
-export declare function iif<T>(condition: NoInfer<Predicate<T>> | boolean, trueOperatorOrValue: NoInfer<StateOperator<T> | T>, elseOperatorOrValue?: NoInfer<StateOperator<T> | T>): StateOperator<T>;

package/operators/insert-item.d.ts

@@ -1,6 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-/**
- * @param value - Value to insert
- * @param [beforePosition] -  Specified index to insert value before, optional
- */
-export declare function insertItem<T>(value: NoInfer<T>, beforePosition?: number): StateOperator<T[]>;

package/operators/patch.d.ts

@@ -1,7 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-type NotUndefined<T> = T extends undefined ? never : T;
-export type ɵPatchSpec<T> = {
-    [P in keyof T]?: T[P] | StateOperator<NotUndefined<T[P]>>;
-};
-export declare function patch<T extends Record<string, any>>(patchObject: NoInfer<ɵPatchSpec<T>>): StateOperator<T>;
-export {};

package/operators/remove-item.d.ts

@@ -1,6 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-import { Predicate } from './utils';
-/**
- * @param selector - index or predicate to remove an item from an array by
- */
-export declare function removeItem<T>(selector: number | NoInfer<Predicate<T>>): StateOperator<T[]>;

package/operators/types.d.ts

@@ -1,56 +0,0 @@
-type _NoInfer<T> = T extends infer S ? S : never;
-/**
- * Blocks the ability of the typescript inferrence engine to be able to use the provided type as part of
- * inferring any type parameters from this usage.
- * @example
- * Primarily used to wrap parameters of functions in order to prevent the TypeScript inferrence engine
- * from inferring a type parameter of the function from the value provided to this parameter.
- * This essentially blocks the Contravariance of the function (through its parameters) so that the
- * function type parameter is purely determined by the Covariant requirements of the function's return type.
- * This is key to creating `StateOperator`s that are typed based on their contextual usage and not on the arguments
- * provided to them. This is critical for type safety and intellisense for State Operators.
- * Here is an example of how this benefits a state operator:
- * ```ts
- * declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
- * declare function appendBad<T>(items: T[]): StateOperator<T[]>;
- *
- * interface AAA {
- *   foo?: boolean;
- *   bar?: boolean;
- * }
- *
- * // Works
- * // (T in append is correctly inferred as AAA)
- * patch<{ test: AAA[] }>({ test: append([{ foo: true }]) });
- *
- * // Incorrectly throws: Type 'AAA' is not assignable to type '{ foo: true; }'.ts(2322)
- * // (T in appendBad is incorrectly inferred as { foo: true; })
- * patch<{ test: AAA[] }>({ test: appendBad([{ foo: true }]) });
- * ```
- *
- */
-export type NoInfer<T> = T extends (infer O)[] ? _NoInfer<O>[] : _NoInfer<T>;
-/**
- * IMPORTANT NOTE: This should not be used externally to the library, rather
- * the exported type `ExistingState<T>` should be used instead.
- *
- * Used to convert a type to its readonly form. This can be given any type, from
- * primitives to objects or arrays that could already be readonly or not.
- * This does not apply the readonly construct to nested objects, but only to the top level type.
- */
-type ɵAsReadonly<T> = T extends Readonly<infer O> ? (O extends T ? Readonly<T> : T) : T;
-/**
- * Represents the existing state that is passed into a `StateOperator` which should
- * not be modified but will be used to build the new state returned by the `StateOperator`.
- */
-export type ExistingState<T> = T extends any ? ɵAsReadonly<T> : never;
-/**
- * This is a monotype unary function that is used to create a new state from an existing state.
- * A state operator is usually created by a function that is given some data
- * to integrate with the state and returns a state operator which integrates this data or instruction.
- *
- * In state management terminology this creator function is commonly referred to as a state operator
- * because it represents the operation to be performed. ie. `patch`, `append`, `insertItem`, `compose`, `iif`, etc.
- */
-export type StateOperator<T> = (existing: ExistingState<T>) => T;
-export {};

package/operators/update-item.d.ts

@@ -1,9 +0,0 @@
-import { NoInfer, StateOperator } from './types';
-import { Predicate } from './utils';
-/**
- * @param selector - Index of item in the array or a predicate function
- * that can be provided in `Array.prototype.findIndex`
- * @param operatorOrValue - New value under the `selector` index or a
- * function that can be applied to an existing value
- */
-export declare function updateItem<T>(selector: number | NoInfer<Predicate<T>>, operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>): StateOperator<T[]>;

package/operators/utils.d.ts

@@ -1,8 +0,0 @@
-import { StateOperator } from './types';
-export type Predicate<T = any> = (value: T | Readonly<T>) => boolean;
-export declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
-export declare function isUndefined(value: any): value is undefined;
-export declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
-export declare function isNumber(value: any): value is number;
-export declare function invalidIndex(index: number): boolean;
-export declare function isNil<T>(value: T | null | undefined): value is null | undefined;

package/plugins/actions.d.ts

@@ -1,15 +0,0 @@
-import { ɵPlainObject } from '@ngxs/store/internals';
-/**
- * Init action
- */
-export declare class InitState {
-    static readonly type = "@@INIT";
-}
-/**
- * Update action
- */
-export declare class UpdateState {
-    readonly addedStates?: ɵPlainObject | undefined;
-    static readonly type = "@@UPDATE_STATE";
-    constructor(addedStates?: ɵPlainObject | undefined);
-}

package/plugins/symbols.d.ts

@@ -1,13 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export declare const NGXS_PLUGINS: InjectionToken<unknown>;
-export type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;
-export type NgxsNextPluginFn = (state: any, mutation: any) => any;
-/**
- * Plugin interface
- */
-export interface NgxsPlugin {
-    /**
-     * Handle the state/action before its submitted to the state handlers.
-     */
-    handle(state: any, action: any, next: NgxsNextPluginFn): any;
-}

package/plugins/utils.d.ts

@@ -1,29 +0,0 @@
-/**
- * Returns the type from an action instance/class.
- * @ignore
- */
-export declare function getActionTypeFromInstance(action: any): string | undefined;
-/**
- * Matches a action
- * @ignore
- */
-export declare function actionMatcher(action1: any): (action2: any) => boolean;
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- */
-export declare const setValue: (obj: any, prop: string, val: any) => any;
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- */
-export declare const getValue: (obj: any, prop: string) => any;

package/schematics/src/actions/actions.factory.d.ts

@@ -1,3 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { ActionsSchema } from './actions.schema';
-export declare function actions(options: ActionsSchema): Rule;

package/schematics/src/ng-add/add-declaration.d.ts

@@ -1,4 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { NormalizedNgxsPackageSchema } from './ng-add.factory';
-export declare function addDeclarationToStandaloneApp(options: NormalizedNgxsPackageSchema): Rule;
-export declare function addDeclarationToNonStandaloneApp(options: NormalizedNgxsPackageSchema): Rule;

package/schematics/src/ng-add/ng-add.factory.d.ts

@@ -1,9 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { LIBRARIES } from '../utils/common/lib.config';
-import { NgxsPackageSchema } from './ng-add.schema';
-export type NormalizedNgxsPackageSchema = {
-    skipInstall: boolean;
-    plugins: LIBRARIES[];
-    project: string;
-};
-export declare function ngAdd(options: NgxsPackageSchema): Rule;

package/schematics/src/starter-kit/starter-kit.factory.d.ts

@@ -1,3 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { StarterKitSchema } from './starter-kit.schema';
-export declare function starterKit(options: StarterKitSchema): Rule;

package/schematics/src/state/state.factory.d.ts

@@ -1,3 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { StateSchema } from './state.schema';
-export declare function state(options: StateSchema): Rule;

package/schematics/src/store/store.factory.d.ts

@@ -1,3 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { StoreSchema } from './store.schema';
-export declare function store(options: StoreSchema): Rule;

package/schematics/src/utils/common/lib.config.d.ts

@@ -1,10 +0,0 @@
-export declare enum LIBRARIES {
-    DEVTOOLS = "@ngxs/devtools-plugin",
-    FORM = "@ngxs/form-plugin",
-    HMR = "@ngxs/hmr-plugin",
-    LOGGER = "@ngxs/logger-plugin",
-    ROUTER = "@ngxs/router-plugin",
-    STORAGE = "@ngxs/storage-plugin",
-    STORE = "@ngxs/store",
-    WEBSOCKET = "@ngxs/websocket-plugin"
-}

package/schematics/src/utils/common/project-files.config.d.ts

@@ -1,3 +0,0 @@
-export declare const PACKAGE_JSON = "package.json";
-export declare const ANGULAR_JSON = "angular.json";
-export declare const TSCONFIG_SPEC_JSON = "src/tsconfig.spec.json";

package/schematics/src/utils/common/properties.d.ts

@@ -1 +0,0 @@
-export declare function isEmpty(value: string | undefined): boolean;

package/schematics/src/utils/config.d.ts

@@ -1,119 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-export interface AppConfig {
-    /**
-     * Name of the app.
-     */
-    name?: string;
-    /**
-     * Directory where app files are placed.
-     */
-    appRoot?: string;
-    /**
-     * The root directory of the app.
-     */
-    root?: string;
-    /**
-     * The output directory for build results.
-     */
-    outDir?: string;
-    /**
-     * List of application assets.
-     */
-    assets?: (string | {
-        /**
-         * The pattern to match.
-         */
-        glob?: string;
-        /**
-         * The dir to search within.
-         */
-        input?: string;
-        /**
-         * The output path (relative to the outDir).
-         */
-        output?: string;
-    })[];
-    /**
-     * URL where files will be deployed.
-     */
-    deployUrl?: string;
-    /**
-     * Base url for the application being built.
-     */
-    baseHref?: string;
-    /**
-     * The runtime platform of the app.
-     */
-    platform?: 'browser' | 'server';
-    /**
-     * The name of the start HTML file.
-     */
-    index?: string;
-    /**
-     * The name of the main entry-point file.
-     */
-    main?: string;
-    /**
-     * The name of the polyfills file.
-     */
-    polyfills?: string;
-    /**
-     * The name of the test entry-point file.
-     */
-    test?: string;
-    /**
-     * The name of the TypeScript configuration file.
-     */
-    tsconfig?: string;
-    /**
-     * The name of the TypeScript configuration file for unit tests.
-     */
-    testTsconfig?: string;
-    /**
-     * The prefix to apply to generated selectors.
-     */
-    prefix?: string;
-    /**
-     * Experimental support for a service worker from @angular/service-worker.
-     */
-    serviceWorker?: boolean;
-    /**
-     * Global styles to be included in the build.
-     */
-    styles?: (string | {
-        input?: string;
-        [name: string]: any;
-    })[];
-    /**
-     * Options to pass to style preprocessors
-     */
-    stylePreprocessorOptions?: {
-        /**
-         * Paths to include. Paths will be resolved to project root.
-         */
-        includePaths?: string[];
-    };
-    /**
-     * Global scripts to be included in the build.
-     */
-    scripts?: (string | {
-        input: string;
-        [name: string]: any;
-    })[];
-    /**
-     * Source file for environment config.
-     */
-    environmentSource?: string;
-    /**
-     * Name and corresponding file for environment config.
-     */
-    environments?: {
-        [name: string]: any;
-    };
-    appShell?: {
-        app: string;
-        route: string;
-    };
-}
-export declare function getWorkspacePath(host: Tree): string | undefined;
-export declare function getWorkspace(host: Tree): any;

package/schematics/src/utils/generate-utils.d.ts

@@ -1,4 +0,0 @@
-import { Rule, Source } from '@angular-devkit/schematics';
-export declare function generateFiles(srcFolder: Source, target: string, substitutions: {
-    [k: string]: any;
-}, generateSpecs?: boolean): Rule;

package/schematics/src/utils/interfaces/package.interface.d.ts

@@ -1,7 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-export interface PackageToJsonInterface {
-    host: Tree;
-    type: string;
-    pkg: string;
-    version: string;
-}

package/schematics/src/utils/ng-utils/ast-utils.d.ts

@@ -1,99 +0,0 @@
-import * as ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
-import { Change } from '@schematics/angular/utility/change';
-/**
- * Add Import `import { symbolName } from fileName` if the import doesn't exit
- * already. Assumes fileToEdit can be resolved and accessed.
- * @param fileToEdit File we want to add import to.
- * @param symbolName Item to import.
- * @param fileName Path to the file.
- * @param isDefault If true, import follows style for importing default exports.
- * @param alias Alias that the symbol should be inserted under.
- * @return Change
- */
-export declare function insertImport(source: ts.SourceFile, fileToEdit: string, symbolName: string, fileName: string, isDefault?: boolean, alias?: string): Change;
-/**
- * Find all nodes from the AST in the subtree of node of SyntaxKind kind.
- * @param node
- * @param kind
- * @param max The maximum number of items to return.
- * @param recursive Continue looking for nodes of kind recursive until end
- * the last child even when node of kind has been found.
- * @return all nodes of kind, or [] if none is found
- */
-export declare function findNodes(node: ts.Node, kind: ts.SyntaxKind, max?: number, recursive?: boolean): ts.Node[];
-/**
- * Find all nodes from the AST in the subtree that satisfy a type guard.
- * @param node
- * @param guard
- * @param max The maximum number of items to return.
- * @param recursive Continue looking for nodes of kind recursive until end
- * the last child even when node of kind has been found.
- * @return all nodes that satisfy the type guard, or [] if none is found
- */
-export declare function findNodes<T extends ts.Node>(node: ts.Node, guard: (node: ts.Node) => node is T, max?: number, recursive?: boolean): T[];
-/**
- * Get all the nodes from a source.
- * @param sourceFile The source file object.
- * @returns {Array<ts.Node>} An array of all the nodes in the source.
- */
-export declare function getSourceNodes(sourceFile: ts.SourceFile): ts.Node[];
-export declare function findNode(node: ts.Node, kind: ts.SyntaxKind, text: string): ts.Node | null;
-/**
- * Insert `toInsert` after the last occurence of `ts.SyntaxKind[nodes[i].kind]`
- * or after the last of occurence of `syntaxKind` if the last occurence is a sub child
- * of ts.SyntaxKind[nodes[i].kind] and save the changes in file.
- *
- * @param nodes insert after the last occurence of nodes
- * @param toInsert string to insert
- * @param file file to insert changes into
- * @param fallbackPos position to insert if toInsert happens to be the first occurence
- * @param syntaxKind the ts.SyntaxKind of the subchildren to insert after
- * @return Change instance
- * @throw Error if toInsert is first occurence but fall back is not set
- */
-export declare function insertAfterLastOccurrence(nodes: ts.Node[] | ts.NodeArray<ts.Node>, toInsert: string, file: string, fallbackPos: number, syntaxKind?: ts.SyntaxKind): Change;
-export declare function getDecoratorMetadata(source: ts.SourceFile, identifier: string, module: string): ts.Node[];
-export declare function getMetadataField(node: ts.ObjectLiteralExpression, metadataField: string): ts.ObjectLiteralElement[];
-export declare function addSymbolToNgModuleMetadata(source: ts.SourceFile, ngModulePath: string, metadataField: string, symbolName: string, importPath?: string | null): Change[];
-/**
- * Custom function to insert a declaration (component, pipe, directive)
- * into NgModule declarations. It also imports the component.
- */
-export declare function addDeclarationToModule(source: ts.SourceFile, modulePath: string, classifiedName: string, importPath: string): Change[];
-/**
- * Custom function to insert an NgModule into NgModule imports. It also imports the module.
- */
-export declare function addImportToModule(source: ts.SourceFile, modulePath: string, classifiedName: string, importPath: string): Change[];
-/**
- * Custom function to insert a provider into NgModule. It also imports it.
- */
-export declare function addProviderToModule(source: ts.SourceFile, modulePath: string, classifiedName: string, importPath: string): Change[];
-/**
- * Custom function to insert an export into NgModule. It also imports it.
- */
-export declare function addExportToModule(source: ts.SourceFile, modulePath: string, classifiedName: string, importPath: string): Change[];
-/**
- * Custom function to insert an export into NgModule. It also imports it.
- */
-export declare function addBootstrapToModule(source: ts.SourceFile, modulePath: string, classifiedName: string, importPath: string): Change[];
-/**
- * Determine if an import already exists.
- */
-export declare function isImported(source: ts.SourceFile, classifiedName: string, importPath: string): boolean;
-/**
- * Returns the RouterModule declaration from NgModule metadata, if any.
- */
-export declare function getRouterModuleDeclaration(source: ts.SourceFile): ts.Expression | undefined;
-/**
- * Adds a new route declaration to a router module (i.e. has a RouterModule declaration)
- */
-export declare function addRouteDeclarationToModule(source: ts.SourceFile, fileToAdd: string, routeLiteral: string): Change;
-/**
- * Determines if a SourceFile has a top-level declaration whose name matches a specific symbol.
- * Can be used to avoid conflicts when inserting new imports into a file.
- * @param sourceFile File in which to search.
- * @param symbolName Name of the symbol to search for.
- * @param skipModule Path of the module that the symbol may have been imported from. Used to
- * avoid false positives where the same symbol we're looking for may have been imported.
- */
-export declare function hasTopLevelIdentifier(sourceFile: ts.SourceFile, symbolName: string, skipModule?: string | null): boolean;

package/schematics/src/utils/ng-utils/ng-ast-utils.d.ts

@@ -1,5 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-import * as ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
-export declare function findBootstrapModuleCall(host: Tree, mainPath: string): ts.CallExpression | null;
-export declare function getAppModulePath(host: Tree, mainPath: string): string;
-export declare function isStandaloneApp(host: Tree, mainPath: string): boolean;

package/schematics/src/utils/ng-utils/project.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-export declare function getProjectMainFile(host: Tree, project?: string): string;

package/schematics/src/utils/ng-utils/standalone/app_config.d.ts

@@ -1,16 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-import * as ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
-/** App config that was resolved to its source node. */
-export interface ResolvedAppConfig {
-    /** Tree-relative path of the file containing the app config. */
-    filePath: string;
-    /** Node defining the app config. */
-    node: ts.ObjectLiteralExpression;
-}
-/**
- * Resolves the node that defines the app config from a bootstrap call.
- * @param bootstrapCall Call for which to resolve the config.
- * @param tree File tree of the project.
- * @param filePath File path of the bootstrap call.
- */
-export declare function findAppConfig(bootstrapCall: ts.CallExpression, tree: Tree, filePath: string): ResolvedAppConfig | null;

package/schematics/src/utils/ng-utils/standalone/code_block.d.ts

@@ -1,46 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-/** Generated code that hasn't been interpolated yet. */
-export interface PendingCode {
-    /** Code that will be inserted. */
-    expression: string;
-    /** Imports that need to be added to the file in which the code is inserted. */
-    imports: PendingImports;
-}
-/** Map keeping track of imports and aliases under which they're referred to in an expresion. */
-type PendingImports = Map<string, Map<string, string>>;
-/**
- * Callback invoked by a Rule that produces the code
- * that needs to be inserted somewhere in the app.
- */
-export type CodeBlockCallback = (block: CodeBlock) => PendingCode;
-/**
- * Utility class used to generate blocks of code that
- * can be inserted by the devkit into a user's app.
- */
-export declare class CodeBlock {
-    private _imports;
-    /** Function used to tag a code block in order to produce a `PendingCode` object. */
-    code: (strings: TemplateStringsArray, ...params: unknown[]) => PendingCode;
-    /**
-     * Used inside of a code block to mark external symbols and which module they should be imported
-     * from. When the code is inserted, the required import statements will be produced automatically.
-     * @param symbolName Name of the external symbol.
-     * @param moduleName Module from which the symbol should be imported.
-     */
-    external: (symbolName: string, moduleName: string) => string;
-    /**
-     * Produces the necessary rules to transform a `PendingCode` object into valid code.
-     * @param initialCode Code pending transformed.
-     * @param filePath Path of the file in which the code will be inserted.
-     */
-    static transformPendingCode(initialCode: PendingCode, filePath: string): {
-        code: {
-            /** Code that will be inserted. */
-            expression: string;
-            /** Imports that need to be added to the file in which the code is inserted. */
-            imports: PendingImports;
-        };
-        rules: Rule[];
-    };
-}
-export {};

package/schematics/src/utils/ng-utils/standalone/index.d.ts

@@ -1 +0,0 @@
-export { addRootImport, addRootProvider } from './rules';

package/schematics/src/utils/ng-utils/standalone/rules.d.ts

@@ -1,38 +0,0 @@
-import { Rule } from '@angular-devkit/schematics';
-import { CodeBlockCallback } from './code_block';
-/**
- * Adds an import to the root of the project.
- * @param project Name of the project to which to add the import.
- * @param callback Function that generates the code block which should be inserted.
- * @example
- *
- * ```ts
- * import { Rule } from '@angular-devkit/schematics';
- * import { addRootImport } from '@schematics/angular/utility';
- *
- * export default function(): Rule {
- *   return addRootImport('default', ({code, external}) => {
- *     return code`${external('MyModule', '@my/module')}.forRoot({})`;
- *   });
- * }
- * ```
- */
-export declare function addRootImport(project: string, callback: CodeBlockCallback): Rule;
-/**
- * Adds a provider to the root of the project.
- * @param project Name of the project to which to add the import.
- * @param callback Function that generates the code block which should be inserted.
- * @example
- *
- * ```ts
- * import { Rule } from '@angular-devkit/schematics';
- * import { addRootProvider } from '@schematics/angular/utility';
- *
- * export default function(): Rule {
- *   return addRootProvider('default', ({code, external}) => {
- *     return code`${external('provideLibrary', '@my/library')}({})`;
- *   });
- * }
- * ```
- */
-export declare function addRootProvider(project: string, callback: CodeBlockCallback): Rule;

package/schematics/src/utils/ng-utils/standalone/util.d.ts

@@ -1,28 +0,0 @@
-import { Tree } from '@angular-devkit/schematics';
-import * as ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
-import { Change } from '@schematics/angular/utility/change';
-/**
- * Finds the main file of a project.
- * @param tree File tree for the project.
- * @param projectName Name of the project in which to search.
- */
-export declare function getMainFilePath(tree: Tree, projectName: string): Promise<string>;
-/**
- * Gets a TypeScript source file at a specific path.
- * @param tree File tree of a project.
- * @param path Path to the file.
- */
-export declare function getSourceFile(tree: Tree, path: string): ts.SourceFile;
-/** Finds the call to `bootstrapApplication` within a file. */
-export declare function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression;
-/**
- * Applies a set of changes to a file.
- * @param tree File tree of the project.
- * @param path Path to the file that is being changed.
- * @param changes Changes that should be applied to the file.
- */
-export declare function applyChangesToFile(tree: Tree, path: string, changes: Change[]): void;
-/** Checks whether a node is a call to `mergeApplicationConfig`. */
-export declare function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression;
-/** Finds the `providers` array literal within an application config. */
-export declare function findProvidersLiteral(config: ts.ObjectLiteralExpression): ts.ArrayLiteralExpression | null;