Graham/angular-cli
1
0
Fork 0
mirror of https://github.com/angular/angular-cli.git synced 2025-05-15 01:54:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

build: transition from ts-api-guardian to dev-infra api-golden utility

Browse Source 
The dev-infra tooling now directly provides public API change testing capabilities that leverage the `api-extractor` utility. These new testing capabilities are shared with framework and components.
`ts-api-guardian` has been removed as a dependency as a result.
This commit is contained in:
Charles Lyding 2021-07-16 13:22:43 -04:00 committed by Joey Perrott
parent 222e711136
commit 1cb07caddc
36 changed files with 5826 additions and 2280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
goldens/BUILD.bazel Normal file
View File

@ -0,0 +1,8 @@
package(default_visibility = ["//visibility:public"])
filegroup(
name = "public-api",
srcs = glob([
"public-api/**/*.md",
]),
)

54
goldens/public-api/BUILD.bazel
View File

@ -1,54 +0,0 @@
load("@npm//ts-api-guardian:index.bzl", "ts_api_guardian_test")
[ts_api_guardian_test(
name = "%s_%s_%sapi" % (
bundle[0],
bundle[1],
bundle[2].replace("src/", "").replace("index", "").replace("_golden-api", "").replace("/", "_"),
),
actual = "angular_cli/packages/%s/%s/npm_package/%s.d.ts" % (
bundle[0],
bundle[1],
bundle[2],
),
allow_module_identifiers = [
"fs",
"ts",
"ajv",
"Symbol",
"webpack",
],
data = glob([
"%s/%s/**/*.d.ts" % (
bundle[0],
bundle[1],
),
]) + [
"//packages/%s/%s:npm_package" % (
bundle[0],
bundle[1],
),
],
golden = "angular_cli/goldens/public-api/%s/%s/%s.d.ts" % (
bundle[0],
bundle[1],
bundle[2],
),
# We don't want to analyse these exports nor add them to the golden files
# in most cases it's because Ts API Guardian doesn't support Symbol Aliases.
# Note: $ must be escaped to $$ because these patterns will be executed by shell
# and $ has a special meaning there.
strip_export_pattern = [
# @angular-devkit/architect
"^BuilderProgressState$$",
# @angular-devkit/schematics
"^workflow$$",
"^formats$$",
# @angular-devkit/build-optimizer
"^buildOptimizerLoader$$",
],
# At the moment using this will ignore a big change
use_angular_tag_rules = False,
) for bundle in [b[:-len(".d.ts")].split("/", 2) for b in glob(
["**/*.d.ts"],
)]]

95
goldens/public-api/angular_devkit/architect/src/index.d.ts vendored
View File

@ -1,95 +0,0 @@
export declare class Architect {
constructor(_host: ArchitectHost, registry?: json.schema.SchemaRegistry, additionalJobRegistry?: experimental.jobs.Registry);
has(name: experimental.jobs.JobName): Observable<boolean>;
scheduleBuilder(name: string, options: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
scheduleTarget(target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
}
export interface BuilderContext {
readonly analytics: analytics.Analytics;
builder: BuilderInfo;
currentDirectory: string;
id: number;
logger: logging.LoggerApi;
target?: Target;
workspaceRoot: string;
addTeardown(teardown: () => Promise<void> | void): void;
getBuilderNameForTarget(target: Target): Promise<string>;
getProjectMetadata(projectName: string): Promise<json.JsonObject>;
getProjectMetadata(target: Target): Promise<json.JsonObject>;
getTargetOptions(target: Target): Promise<json.JsonObject>;
reportProgress(current: number, total?: number, status?: string): void;
reportRunning(): void;
reportStatus(status: string): void;
scheduleBuilder(builderName: string, options?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
scheduleTarget(target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
validateOptions<T extends json.JsonObject = json.JsonObject>(options: json.JsonObject, builderName: string): Promise<T>;
}
export interface BuilderHandlerFn<A> {
(input: A, context: BuilderContext): BuilderOutputLike;
}
export declare type BuilderInfo = json.JsonObject & {
builderName: string;
description: string;
optionSchema: json.schema.JsonSchema;
};
export declare type BuilderInput = json.JsonObject & RealBuilderInput;
export declare type BuilderOutput = json.JsonObject & RealBuilderOutput;
export declare type BuilderOutputLike = AsyncIterable<BuilderOutput> | SubscribableOrPromise<BuilderOutput> | BuilderOutput;
export declare type BuilderProgress = json.JsonObject & RealBuilderProgress & TypedBuilderProgress;
export declare type BuilderProgressReport = BuilderProgress & {
target?: Target;
builder: BuilderInfo;
};
export declare type BuilderRegistry = experimental.jobs.Registry<json.JsonObject, BuilderInput, BuilderOutput>;
export interface BuilderRun {
id: number;
info: BuilderInfo;
output: Observable<BuilderOutput>;
progress: Observable<BuilderProgressReport>;
result: Promise<BuilderOutput>;
stop(): Promise<void>;
}
export declare function createBuilder<OptT = json.JsonObject, OutT extends BuilderOutput = BuilderOutput>(fn: BuilderHandlerFn<OptT>): Builder<OptT & json.JsonObject>;
export declare function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Observable<T>;
export declare function isBuilderOutput(obj: any): obj is BuilderOutput;
export interface ScheduleOptions {
analytics?: analytics.Analytics;
logger?: logging.Logger;
}
export declare function scheduleTargetAndForget(context: BuilderContext, target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Observable<BuilderOutput>;
export declare type Target = json.JsonObject & RealTarget;
export declare function targetFromTargetString(str: string): Target;
export declare function targetStringFromTarget({ project, target, configuration }: Target): string;
export declare type TypedBuilderProgress = {
state: BuilderProgressState.Stopped;
} | {
state: BuilderProgressState.Error;
error: json.JsonValue;
} | {
state: BuilderProgressState.Waiting;
status?: string;
} | {
state: BuilderProgressState.Running;
status?: string;
current: number;
total?: number;
};

151
goldens/public-api/angular_devkit/architect/src/index.md Normal file
View File

@ -0,0 +1,151 @@
## API Report File for "@angular-devkit/architect"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { analytics } from '@angular-devkit/core';
import { experimental } from '@angular-devkit/core';
import { json } from '@angular-devkit/core';
import { logging } from '@angular-devkit/core';
import { Observable } from 'rxjs';
import { SubscribableOrPromise } from 'rxjs';
// @public (undocumented)
export class Architect {
constructor(_host: ArchitectHost, registry?: json.schema.SchemaRegistry, additionalJobRegistry?: experimental.jobs.Registry);
// (undocumented)
has(name: experimental.jobs.JobName): Observable<boolean>;
// (undocumented)
scheduleBuilder(name: string, options: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
// (undocumented)
scheduleTarget(target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>;
}
// @public
export interface BuilderContext {
addTeardown(teardown: () => Promise<void> | void): void;
readonly analytics: analytics.Analytics;
builder: BuilderInfo;
currentDirectory: string;
getBuilderNameForTarget(target: Target): Promise<string>;
// (undocumented)
getProjectMetadata(projectName: string): Promise<json.JsonObject>;
// (undocumented)
getProjectMetadata(target: Target): Promise<json.JsonObject>;
getTargetOptions(target: Target): Promise<json.JsonObject>;
id: number;
logger: logging.LoggerApi;
reportProgress(current: number, total?: number, status?: string): void;
reportRunning(): void;
reportStatus(status: string): void;
scheduleBuilder(builderName: string, options?: json.JsonObject, scheduleOptions?: ScheduleOptions_2): Promise<BuilderRun>;
scheduleTarget(target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions_2): Promise<BuilderRun>;
target?: Target;
validateOptions<T extends json.JsonObject = json.JsonObject>(options: json.JsonObject, builderName: string): Promise<T>;
workspaceRoot: string;
}
// @public
export interface BuilderHandlerFn<A> {
(input: A, context: BuilderContext): BuilderOutputLike;
}
// @public
export type BuilderInfo = json.JsonObject & {
builderName: string;
description: string;
optionSchema: json.schema.JsonSchema;
};
// @public
export type BuilderInput = json.JsonObject & Schema;
// @public (undocumented)
export type BuilderOutput = json.JsonObject & Schema_2;
// @public
export type BuilderOutputLike = AsyncIterable<BuilderOutput> | SubscribableOrPromise<BuilderOutput> | BuilderOutput;
// @public (undocumented)
export type BuilderProgress = json.JsonObject & Schema_3 & TypedBuilderProgress;
// @public
export type BuilderProgressReport = BuilderProgress & {
target?: Target;
builder: BuilderInfo;
};
// @public (undocumented)
export enum BuilderProgressState {
// (undocumented)
Error = "error",
// (undocumented)
Running = "running",
// (undocumented)
Stopped = "stopped",
// (undocumented)
Waiting = "waiting"
}
// @public (undocumented)
export type BuilderRegistry = experimental.jobs.Registry<json.JsonObject, BuilderInput, BuilderOutput>;
// @public
export interface BuilderRun {
id: number;
info: BuilderInfo;
output: Observable<BuilderOutput>;
progress: Observable<BuilderProgressReport>;
result: Promise<BuilderOutput>;
stop(): Promise<void>;
}
// @public (undocumented)
export function createBuilder<OptT = json.JsonObject, OutT extends BuilderOutput = BuilderOutput>(fn: BuilderHandlerFn<OptT>): Builder<OptT & json.JsonObject>;
// @public (undocumented)
export function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Observable<T>;
// @public (undocumented)
export function isBuilderOutput(obj: any): obj is BuilderOutput;
// @public (undocumented)
export interface ScheduleOptions {
// (undocumented)
analytics?: analytics.Analytics;
// (undocumented)
logger?: logging.Logger;
}
// @public
export function scheduleTargetAndForget(context: BuilderContext, target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions_2): Observable<BuilderOutput>;
// @public (undocumented)
export type Target = json.JsonObject & Target_2;
// @public
export function targetFromTargetString(str: string): Target;
// @public
export function targetStringFromTarget({ project, target, configuration }: Target): string;
// @public
export type TypedBuilderProgress = {
state: BuilderProgressState.Stopped;
} | {
state: BuilderProgressState.Error;
error: json.JsonValue;
} | {
state: BuilderProgressState.Waiting;
status?: string;
} | {
state: BuilderProgressState.Running;
status?: string;
current: number;
total?: number;
};
// (No @packageDocumentation comment for this package)
```

31
goldens/public-api/angular_devkit/architect/testing/index.d.ts vendored
View File

@ -1,31 +0,0 @@
export declare class TestingArchitectHost implements ArchitectHost {
currentDirectory: string;
workspaceRoot: string;
constructor(workspaceRoot?: string, currentDirectory?: string, _backendHost?: ArchitectHost | null);
addBuilder(builderName: string, builder: Builder, description?: string, optionSchema?: json.schema.JsonSchema): void;
addBuilderFromPackage(packageName: string): Promise<void>;
addTarget(target: Target, builderName: string, options?: json.JsonObject): void;
getBuilderNameForTarget(target: Target): Promise<string | null>;
getCurrentDirectory(): Promise<string>;
getOptionsForTarget(target: Target): Promise<json.JsonObject | null>;
getProjectMetadata(target: Target | string): Promise<json.JsonObject | null>;
getWorkspaceRoot(): Promise<string>;
loadBuilder(info: BuilderInfo): Promise<Builder | null>;
resolveBuilder(builderName: string): Promise<BuilderInfo | null>;
}
export declare class TestProjectHost extends NodeJsSyncHost {
protected _templateRoot: Path;
constructor(_templateRoot: Path);
appendToFile(path: string, str: string): void;
copyFile(from: string, to: string): void;
fileMatchExists(dir: string, regex: RegExp): PathFragment | undefined;
initialize(): Observable<void>;
replaceInFile(path: string, match: RegExp | string, replacement: string): void;
restore(): Observable<void>;
root(): Path;
scopedSync(): virtualFs.SyncDelegateHost<Stats>;
writeMultipleFiles(files: {
[path: string]: string | ArrayBufferLike | Buffer;
}): void;
}

100
goldens/public-api/angular_devkit/benchmark/src/index.d.ts vendored
View File

@ -1,100 +0,0 @@
export interface AggregatedMetric extends Metric {
componentValues: number[];
}
export interface AggregatedProcessStats {
cpu: number;
ctime: number;
elapsed: number;
memory: number;
pid: number;
ppid: number;
processes: number;
timestamp: number;
}
export declare const aggregateMetricGroups: (g1: MetricGroup, g2: MetricGroup) => MetricGroup;
export declare const aggregateMetrics: (m1: Metric | AggregatedMetric, m2: Metric | AggregatedMetric) => AggregatedMetric;
export declare type BenchmarkReporter = (command: Command, groups: MetricGroup[]) => void;
export declare type Capture = (stats: Observable<AggregatedProcessStats>) => Observable<MetricGroup>;
export declare class Command {
args: string[];
cmd: string;
cwd: string;
expectedExitCode: number;
constructor(cmd: string, args?: string[], cwd?: string, expectedExitCode?: number);
toString(): string;
}
export declare const cumulativeMovingAverage: (acc: number, val: number, accSize: number) => number;
export declare const defaultReporter: (logger: logging.Logger) => BenchmarkReporter;
export declare const defaultStatsCapture: Capture;
export declare class LocalMonitoredProcess implements MonitoredProcess {
stats$: Observable<AggregatedProcessStats>;
stderr$: Observable<Buffer>;
stdout$: Observable<Buffer>;
constructor(command: Command, useProcessTime?: boolean);
resetElapsedTimer(): void;
run(): Observable<number>;
}
export declare function main({ args, stdout, stderr, }: MainOptions): Promise<0 | 1>;
export interface MainOptions {
args: string[];
stderr?: ProcessOutput;
stdout?: ProcessOutput;
}
export declare const max: (v1: number, v2: number) => number;
export declare class MaximumRetriesExceeded extends BaseException {
constructor(retries: number);
}
export interface Metric {
componentValues?: number[];
name: string;
unit: string;
value: number;
}
export interface MetricGroup {
metrics: (Metric | AggregatedMetric)[];
name: string;
}
export interface MonitoredProcess {
stats$: Observable<AggregatedProcessStats>;
stderr$: Observable<Buffer>;
stdout$: Observable<Buffer>;
run(): Observable<number>;
toString(): string;
}
export declare function runBenchmark({ command, captures, reporters, iterations, retries, logger, }: RunBenchmarkOptions): Observable<MetricGroup[]>;
export interface RunBenchmarkOptions {
captures: Capture[];
command: Command;
expectedExitCode?: number;
iterations?: number;
logger?: logging.Logger;
reporters: BenchmarkReporter[];
retries?: number;
}
export declare function runBenchmarkWatch({ command, captures, reporters, iterations, retries, logger, watchMatcher, watchTimeout, watchCommand, }: RunBenchmarkWatchOptions): Observable<MetricGroup[]>;
export interface RunBenchmarkWatchOptions extends RunBenchmarkOptions {
watchCommand: Command;
watchMatcher: string;
watchTimeout?: number;
}

327
goldens/public-api/angular_devkit/build_angular/src/index.md Normal file
View File

@ -0,0 +1,327 @@
## API Report File for "@angular-devkit/build-angular"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { BuilderContext } from '@angular-devkit/architect';
import { BuilderOutput } from '@angular-devkit/architect';
import { BuildResult } from '@angular-devkit/build-webpack';
import { ConfigOptions } from 'karma';
import { DevServerBuildOutput } from '@angular-devkit/build-webpack';
import { json } from '@angular-devkit/core';
import { JsonObject } from '@angular-devkit/core';
import { Observable } from 'rxjs';
import webpack from 'webpack';
import * as webpack_2 from 'webpack';
import { WebpackLoggingCallback } from '@angular-devkit/build-webpack';
// @public (undocumented)
export type AssetPattern = AssetPatternObject | string;
// @public (undocumented)
export interface AssetPatternObject {
followSymlinks?: boolean;
glob: string;
ignore?: string[];
input: string;
output: string;
}
// @public
export interface BrowserBuilderOptions {
allowedCommonJsDependencies?: string[];
aot?: boolean;
assets?: AssetPattern[];
baseHref?: string;
budgets?: Budget[];
buildOptimizer?: boolean;
commonChunk?: boolean;
crossOrigin?: CrossOrigin;
deleteOutputPath?: boolean;
deployUrl?: string;
// @deprecated
extractCss?: boolean;
extractLicenses?: boolean;
fileReplacements?: FileReplacement[];
i18nMissingTranslation?: I18NMissingTranslation;
index: IndexUnion;
inlineStyleLanguage?: InlineStyleLanguage;
localize?: Localize;
main: string;
namedChunks?: boolean;
ngswConfigPath?: string;
optimization?: OptimizationUnion;
outputHashing?: OutputHashing;
outputPath: string;
poll?: number;
polyfills?: string;
preserveSymlinks?: boolean;
progress?: boolean;
resourcesOutputPath?: string;
scripts?: ExtraEntryPoint[];
serviceWorker?: boolean;
// @deprecated
showCircularDependencies?: boolean;
sourceMap?: SourceMapUnion;
statsJson?: boolean;
stylePreprocessorOptions?: StylePreprocessorOptions;
styles?: ExtraEntryPoint[];
subresourceIntegrity?: boolean;
tsConfig: string;
vendorChunk?: boolean;
verbose?: boolean;
watch?: boolean;
webWorkerTsConfig?: string;
}
// @public
export type BrowserBuilderOutput = json.JsonObject & BuilderOutput & {
baseOutputPath: string;
outputPaths: string[];
outputPath: string;
};
// @public (undocumented)
export interface Budget {
baseline?: string;
error?: string;
maximumError?: string;
maximumWarning?: string;
minimumError?: string;
minimumWarning?: string;
name?: string;
type: Type;
warning?: string;
}
// @public
export enum CrossOrigin {
// (undocumented)
Anonymous = "anonymous",
// (undocumented)
None = "none",
// (undocumented)
UseCredentials = "use-credentials"
}
// @public (undocumented)
export type DevServerBuilderOptions = Schema & json.JsonObject;
// @public
export type DevServerBuilderOutput = DevServerBuildOutput & {
baseUrl: string;
};
// @public
export function executeBrowserBuilder(options: BrowserBuilderOptions, context: BuilderContext, transforms?: {
webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;
logging?: WebpackLoggingCallback;
indexHtml?: IndexHtmlTransform;
}): Observable<BrowserBuilderOutput>;
// @public
export function executeDevServerBuilder(options: DevServerBuilderOptions, context: BuilderContext, transforms?: {
webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;
logging?: WebpackLoggingCallback;
indexHtml?: IndexHtmlTransform;
}): Observable<DevServerBuilderOutput>;
// @public
export function executeExtractI18nBuilder(options: ExtractI18nBuilderOptions, context: BuilderContext, transforms?: {
webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;
}): Promise<BuildResult>;
// @public
export function executeKarmaBuilder(options: KarmaBuilderOptions, context: BuilderContext, transforms?: {
webpackConfiguration?: ExecutionTransformer<webpack_2.Configuration>;
karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions;
}): Observable<BuilderOutput>;
// @public
export function executeNgPackagrBuilder(options: NgPackagrBuilderOptions, context: BuilderContext): Observable<BuilderOutput>;
// @public
export function executeProtractorBuilder(options: ProtractorBuilderOptions, context: BuilderContext): Promise<BuilderOutput>;
// @public
export function executeServerBuilder(options: ServerBuilderOptions, context: BuilderContext, transforms?: {
webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;
}): Observable<ServerBuilderOutput>;
// @public
export type ExecutionTransformer<T> = (input: T) => T | Promise<T>;
// @public (undocumented)
export type ExtractI18nBuilderOptions = Schema_2 & JsonObject;
// @public (undocumented)
export type ExtraEntryPoint = ExtraEntryPointObject | string;
// @public (undocumented)
export interface ExtraEntryPointObject {
bundleName?: string;
inject?: boolean;
input: string;
}
// @public (undocumented)
export interface FileReplacement {
// (undocumented)
replace?: string;
// (undocumented)
replaceWith?: string;
// (undocumented)
src?: string;
// (undocumented)
with?: string;
}
// @public
export interface KarmaBuilderOptions {
assets?: AssetPattern_2[];
browsers?: string;
codeCoverage?: boolean;
codeCoverageExclude?: string[];
fileReplacements?: FileReplacement_2[];
include?: string[];
inlineStyleLanguage?: InlineStyleLanguage_2;
karmaConfig: string;
main: string;
poll?: number;
polyfills?: string;
preserveSymlinks?: boolean;
progress?: boolean;
reporters?: string[];
scripts?: ExtraEntryPoint_2[];
sourceMap?: SourceMapUnion_3;
stylePreprocessorOptions?: StylePreprocessorOptions_2;
styles?: ExtraEntryPoint_2[];
tsConfig: string;
watch?: boolean;
webWorkerTsConfig?: string;
}
// @public (undocumented)
export type KarmaConfigOptions = ConfigOptions & {
buildWebpack?: unknown;
configFile?: string;
};
// @public
export interface NgPackagrBuilderOptions {
project: string;
tsConfig?: string;
watch?: boolean;
}
// @public (undocumented)
export interface OptimizationObject {
fonts?: FontsUnion;
scripts?: boolean;
styles?: StylesUnion;
}
// @public
export type OptimizationUnion = boolean | OptimizationObject;
// @public
export enum OutputHashing {
// (undocumented)
All = "all",
// (undocumented)
Bundles = "bundles",
// (undocumented)
Media = "media",
// (undocumented)
None = "none"
}
// @public
export interface ProtractorBuilderOptions {
baseUrl?: string;
devServerTarget?: string;
grep?: string;
host?: string;
invertGrep?: boolean;
port?: number;
protractorConfig: string;
specs?: string[];
suite?: string;
webdriverUpdate?: boolean;
}
// @public (undocumented)
export interface ServerBuilderOptions {
bundleDependencies?: BundleDependenciesUnion;
deleteOutputPath?: boolean;
deployUrl?: string;
externalDependencies?: string[];
extractLicenses?: boolean;
fileReplacements?: FileReplacement_3[];
i18nMissingTranslation?: I18NMissingTranslation_2;
inlineStyleLanguage?: InlineStyleLanguage_3;
localize?: Localize_2;
main: string;
namedChunks?: boolean;
optimization?: OptimizationUnion_3;
outputHashing?: OutputHashing_2;
outputPath: string;
poll?: number;
preserveSymlinks?: boolean;
progress?: boolean;
resourcesOutputPath?: string;
// @deprecated
showCircularDependencies?: boolean;
sourceMap?: SourceMapUnion_4;
statsJson?: boolean;
stylePreprocessorOptions?: StylePreprocessorOptions_3;
tsConfig: string;
verbose?: boolean;
watch?: boolean;
}
// @public
export type ServerBuilderOutput = json.JsonObject & BuilderOutput & {
baseOutputPath: string;
outputPaths: string[];
outputPath: string;
};
// @public (undocumented)
export interface SourceMapObject {
hidden?: boolean;
scripts?: boolean;
styles?: boolean;
vendor?: boolean;
}
// @public
export type SourceMapUnion = boolean | SourceMapObject;
// @public
export interface StylePreprocessorOptions {
includePaths?: string[];
}
// @public
export enum Type {
// (undocumented)
All = "all",
// (undocumented)
AllScript = "allScript",
// (undocumented)
Any = "any",
// (undocumented)
AnyComponentStyle = "anyComponentStyle",
// (undocumented)
AnyScript = "anyScript",
// (undocumented)
Bundle = "bundle",
// (undocumented)
Initial = "initial"
}
// (No @packageDocumentation comment for this package)
```

32
goldens/public-api/angular_devkit/build_optimizer/src/_golden-api.d.ts vendored
View File

@ -1,32 +0,0 @@
export declare function buildOptimizer(options: BuildOptimizerOptions): TransformJavascriptOutput;
export declare const buildOptimizerLoaderPath: string;
export declare class BuildOptimizerWebpackPlugin {
apply(compiler: Compiler): void;
}
export default function buildOptimizerLoader(this: {
resourcePath: string;
_module: {
factoryMeta: {
skipBuildOptimizer?: boolean;
sideEffectFree?: boolean;
};
};
cacheable(): void;
callback(error?: Error | null, content?: string, sourceMap?: unknown): void;
getOptions(): unknown;
}, content: string, previousSourceMap: RawSourceMap): void;
export declare function getPrefixClassesTransformer(): ts.TransformerFactory<ts.SourceFile>;
export declare function getPrefixFunctionsTransformer(): ts.TransformerFactory<ts.SourceFile>;
export declare function getScrubFileTransformer(program?: ts.Program): ts.TransformerFactory<ts.SourceFile>;
export declare function getScrubFileTransformerForCore(program?: ts.Program): ts.TransformerFactory<ts.SourceFile>;
export declare function getWrapEnumsTransformer(): ts.TransformerFactory<ts.SourceFile>;
export declare function transformJavascript(options: TransformJavascriptOptions): TransformJavascriptOutput;

57
goldens/public-api/angular_devkit/build_optimizer/src/index.md Normal file
View File

@ -0,0 +1,57 @@
## API Report File for "@angular-devkit/build-optimizer"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import type { Compiler } from 'webpack';
import { RawSourceMap } from 'source-map';
import * as ts from 'typescript';
// @public (undocumented)
export function buildOptimizer(options: BuildOptimizerOptions): TransformJavascriptOutput;
// @public (undocumented)
export function buildOptimizerLoader(this: {
resourcePath: string;
_module: {
factoryMeta: {
skipBuildOptimizer?: boolean;
sideEffectFree?: boolean;
};
};
cacheable(): void;
callback(error?: Error | null, content?: string, sourceMap?: unknown): void;
getOptions(): unknown;
}, content: string, previousSourceMap: RawSourceMap): void;
// @public (undocumented)
export const buildOptimizerLoaderPath: string;
// @public (undocumented)
export class BuildOptimizerWebpackPlugin {
// (undocumented)
apply(compiler: Compiler): void;
}
// @public (undocumented)
export function getPrefixClassesTransformer(): ts.TransformerFactory<ts.SourceFile>;
// @public (undocumented)
export function getPrefixFunctionsTransformer(): ts.TransformerFactory<ts.SourceFile>;
// @public (undocumented)
export function getScrubFileTransformer(program?: ts.Program): ts.TransformerFactory<ts.SourceFile>;
// @public (undocumented)
export function getScrubFileTransformerForCore(program?: ts.Program): ts.TransformerFactory<ts.SourceFile>;
// @public (undocumented)
export function getWrapEnumsTransformer(): ts.TransformerFactory<ts.SourceFile>;
// @public (undocumented)
export function transformJavascript(options: TransformJavascriptOptions): TransformJavascriptOutput;
// (No @packageDocumentation comment for this package)
```

78
goldens/public-api/angular_devkit/build_webpack/src/index.md Normal file
View File

@ -0,0 +1,78 @@
## API Report File for "@angular-devkit/build-webpack"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { BuilderContext } from '@angular-devkit/architect';
import { BuilderOutput } from '@angular-devkit/architect';
import { Observable } from 'rxjs';
import webpack from 'webpack';
import WebpackDevServer from 'webpack-dev-server';
// @public (undocumented)
export type BuildResult = BuilderOutput & {
emittedFiles?: EmittedFiles[];
webpackStats?: webpack.StatsCompilation;
outputPath: string;
};
// @public (undocumented)
export type DevServerBuildOutput = BuildResult & {
port: number;
family: string;
address: string;
};
// @public (undocumented)
export interface EmittedFiles {
// (undocumented)
asset?: boolean;
// (undocumented)
extension: string;
// (undocumented)
file: string;
// (undocumented)
id?: string;
// (undocumented)
initial: boolean;
// (undocumented)
name?: string;
}
// @public (undocumented)
export function runWebpack(config: webpack.Configuration, context: BuilderContext, options?: {
logging?: WebpackLoggingCallback;
webpackFactory?: WebpackFactory;
shouldProvideStats?: boolean;
}): Observable<BuildResult>;
// @public (undocumented)
export function runWebpackDevServer(config: webpack.Configuration, context: BuilderContext, options?: {
devServerConfig?: WebpackDevServer.Configuration;
logging?: WebpackLoggingCallback;
webpackFactory?: WebpackFactory;
webpackDevServerFactory?: WebpackDevServerFactory;
}): Observable<DevServerBuildOutput>;
// @public (undocumented)
export type WebpackBuilderSchema = Schema;
// @public (undocumented)
export type WebpackDevServerFactory = typeof WebpackDevServer;
// @public (undocumented)
export interface WebpackFactory {
// (undocumented)
(config: webpack.Configuration): Observable<webpack.Compiler> | webpack.Compiler;
}
// @public (undocumented)
export interface WebpackLoggingCallback {
// (undocumented)
(stats: webpack.Stats, config: webpack.Configuration): void;
}
// (No @packageDocumentation comment for this package)
```

42
goldens/public-api/angular_devkit/core/node/_golden-api.d.ts vendored
View File

@ -1,42 +0,0 @@
export declare function createConsoleLogger(verbose?: boolean, stdout?: ProcessOutput, stderr?: ProcessOutput, colors?: Partial<Record<logging.LogLevel, (s: string) => string>>): logging.Logger;
export declare function isDirectory(filePath: string): boolean;
export declare function isFile(filePath: string): boolean;
export declare class NodeJsAsyncHost implements virtualFs.Host<Stats> {
get capabilities(): virtualFs.HostCapabilities;
delete(path: Path): Observable<void>;
exists(path: Path): Observable<boolean>;
isDirectory(path: Path): Observable<boolean>;
isFile(path: Path): Observable<boolean>;
list(path: Path): Observable<PathFragment[]>;
read(path: Path): Observable<virtualFs.FileBuffer>;
rename(from: Path, to: Path): Observable<void>;
stat(path: Path): Observable<virtualFs.Stats<Stats>>;
watch(path: Path, _options?: virtualFs.HostWatchOptions): Observable<virtualFs.HostWatchEvent> | null;
write(path: Path, content: virtualFs.FileBuffer): Observable<void>;
}
export declare class NodeJsSyncHost implements virtualFs.Host<Stats> {
get capabilities(): virtualFs.HostCapabilities;
delete(path: Path): Observable<void>;
exists(path: Path): Observable<boolean>;
isDirectory(path: Path): Observable<boolean>;
isFile(path: Path): Observable<boolean>;
list(path: Path): Observable<PathFragment[]>;
read(path: Path): Observable<virtualFs.FileBuffer>;
rename(from: Path, to: Path): Observable<void>;
stat(path: Path): Observable<virtualFs.Stats<Stats>>;
watch(path: Path, _options?: virtualFs.HostWatchOptions): Observable<virtualFs.HostWatchEvent> | null;
write(path: Path, content: virtualFs.FileBuffer): Observable<void>;
}
export declare class NodeModuleJobRegistry<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> implements core_experimental.jobs.Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {
protected _resolve(name: string): string | null;
get<A extends MinimumArgumentValueT, I extends MinimumInputValueT, O extends MinimumOutputValueT>(name: core_experimental.jobs.JobName): Observable<core_experimental.jobs.JobHandler<A, I, O> | null>;
}
export interface ProcessOutput {
write(buffer: string | Buffer): boolean;
}

1322
goldens/public-api/angular_devkit/core/node/index.md Normal file
View File

File diff suppressed because it is too large Load Diff

8
goldens/public-api/angular_devkit/core/node/testing/index.d.ts vendored
View File

@ -1,8 +0,0 @@
export declare class TempScopedNodeJsSyncHost extends virtualFs.ScopedHost<fs.Stats> {
protected _root: Path;
protected _sync?: virtualFs.SyncDelegateHost<fs.Stats>;
get files(): Path[];
get root(): Path;
get sync(): virtualFs.SyncDelegateHost<fs.Stats>;
constructor();
}

1097
goldens/public-api/angular_devkit/core/src/_golden-api.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

2367
goldens/public-api/angular_devkit/core/src/index.md Normal file
View File

File diff suppressed because it is too large Load Diff

620
goldens/public-api/angular_devkit/schematics/src/_golden-api.d.ts vendored
View File

@ -1,620 +0,0 @@
export declare type Action = CreateFileAction | OverwriteFileAction | RenameFileAction | DeleteFileAction;
export interface ActionBase {
readonly id: number;
readonly parent: number;
readonly path: Path;
}
export declare class ActionList implements Iterable<Action> {
get length(): number;
[Symbol.iterator](): IterableIterator<Action>;
protected _action(action: Partial<Action>): void;
create(path: Path, content: Buffer): void;
delete(path: Path): void;
find(predicate: (value: Action) => boolean): Action | null;
forEach(fn: (value: Action, index: number, array: Action[]) => void, thisArg?: {}): void;
get(i: number): Action;
has(action: Action): boolean;
optimize(): void;
overwrite(path: Path, content: Buffer): void;
push(action: Action): void;
rename(path: Path, to: Path): void;
}
export declare function apply(source: Source, rules: Rule[]): Source;
export declare function applyContentTemplate<T>(options: T): FileOperator;
export declare function applyPathTemplate<T extends PathTemplateData>(data: T, options?: PathTemplateOptions): FileOperator;
export declare function applyTemplates<T>(options: T): Rule;
export declare function applyToSubtree(path: string, rules: Rule[]): Rule;
export declare function asSource(rule: Rule): Source;
export declare type AsyncFileOperator = (tree: FileEntry) => Observable<FileEntry | null>;
export declare abstract class BaseWorkflow implements Workflow {
protected _context: WorkflowExecutionContext[];
protected _dryRun: boolean;
protected _engine: Engine<{}, {}>;
protected _engineHost: EngineHost<{}, {}>;
protected _force: boolean;
protected _host: virtualFs.Host;
protected _lifeCycle: Subject<LifeCycleEvent>;
protected _registry: schema.CoreSchemaRegistry;
protected _reporter: Subject<DryRunEvent>;
get context(): Readonly<WorkflowExecutionContext>;
get engine(): Engine<{}, {}>;
get engineHost(): EngineHost<{}, {}>;
get lifeCycle(): Observable<LifeCycleEvent>;
get registry(): schema.SchemaRegistry;
get reporter(): Observable<DryRunEvent>;
constructor(options: BaseWorkflowOptions);
protected _createSinks(): Sink[];
execute(options: Partial<WorkflowExecutionContext> & RequiredWorkflowExecutionContext): Observable<void>;
}
export interface BaseWorkflowOptions {
dryRun?: boolean;
engineHost: EngineHost<{}, {}>;
force?: boolean;
host: virtualFs.Host;
registry?: schema.CoreSchemaRegistry;
}
export declare function branchAndMerge(rule: Rule, strategy?: MergeStrategy): Rule;
export declare function callRule(rule: Rule, input: Tree | Observable<Tree>, context: SchematicContext): Observable<Tree>;
export declare function callSource(source: Source, context: SchematicContext): Observable<Tree>;
export declare function chain(rules: Rule[]): Rule;
export declare class CircularCollectionException extends BaseException {
constructor(name: string);
}
export interface Collection<CollectionMetadataT extends object, SchematicMetadataT extends object> {
readonly baseDescriptions?: Array<CollectionDescription<CollectionMetadataT>>;
readonly description: CollectionDescription<CollectionMetadataT>;
createSchematic(name: string, allowPrivate?: boolean): Schematic<CollectionMetadataT, SchematicMetadataT>;
listSchematicNames(): string[];
}
export declare type CollectionDescription<CollectionMetadataT extends object> = CollectionMetadataT & {
readonly name: string;
readonly extends?: string[];
};
export declare class CollectionImpl<CollectionT extends object, SchematicT extends object> implements Collection<CollectionT, SchematicT> {
readonly baseDescriptions?: CollectionDescription<CollectionT>[] | undefined;
get description(): CollectionDescription<CollectionT>;
get name(): string;
constructor(_description: CollectionDescription<CollectionT>, _engine: SchematicEngine<CollectionT, SchematicT>, baseDescriptions?: CollectionDescription<CollectionT>[] | undefined);
createSchematic(name: string, allowPrivate?: boolean): Schematic<CollectionT, SchematicT>;
listSchematicNames(): string[];
}
export declare function composeFileOperators(operators: FileOperator[]): FileOperator;
export declare class ContentHasMutatedException extends BaseException {
constructor(path: string);
}
export declare function contentTemplate<T>(options: T): Rule;
export interface CreateFileAction extends ActionBase {
readonly content: Buffer;
readonly kind: 'c';
}
export declare class DelegateTree implements Tree {
protected _other: Tree;
get actions(): Action[];
get root(): DirEntry;
constructor(_other: Tree);
apply(action: Action, strategy?: MergeStrategy): void;
beginUpdate(path: string): UpdateRecorder;
branch(): Tree;
commitUpdate(record: UpdateRecorder): void;
create(path: string, content: Buffer | string): void;
delete(path: string): void;
exists(path: string): boolean;
get(path: string): FileEntry | null;
getDir(path: string): DirEntry;
merge(other: Tree, strategy?: MergeStrategy): void;
overwrite(path: string, content: Buffer | string): void;
read(path: string): Buffer | null;
rename(from: string, to: string): void;
visit(visitor: FileVisitor): void;
}
export interface DeleteFileAction extends ActionBase {
readonly kind: 'd';
}
export interface DirEntry {
readonly parent: DirEntry | null;
readonly path: Path;
readonly subdirs: PathFragment[];
readonly subfiles: PathFragment[];
dir(name: PathFragment): DirEntry;
file(name: PathFragment): FileEntry | null;
visit(visitor: FileVisitor): void;
}
export interface DryRunCreateEvent {
content: Buffer;
kind: 'create';
path: string;
}
export interface DryRunDeleteEvent {
kind: 'delete';
path: string;
}
export interface DryRunErrorEvent {
description: 'alreadyExist' | 'doesNotExist';
kind: 'error';
path: string;
}
export declare type DryRunEvent = DryRunErrorEvent | DryRunDeleteEvent | DryRunCreateEvent | DryRunUpdateEvent | DryRunRenameEvent;
export interface DryRunRenameEvent {
kind: 'rename';
path: string;
to: string;
}
export declare class DryRunSink extends HostSink {
protected _fileAlreadyExistExceptionSet: Set<string>;
protected _fileDoesNotExistExceptionSet: Set<string>;
protected _subject: Subject<DryRunEvent>;
readonly reporter: Observable<DryRunEvent>;
constructor(host: virtualFs.Host, force?: boolean);
_done(): Observable<void>;
protected _fileAlreadyExistException(path: string): void;
protected _fileDoesNotExistException(path: string): void;
}
export interface DryRunUpdateEvent {
content: Buffer;
kind: 'update';
path: string;
}
export declare function empty(): Source;
export declare class EmptyTree extends HostTree {
constructor();
}
export interface Engine<CollectionMetadataT extends object, SchematicMetadataT extends object> {
readonly defaultMergeStrategy: MergeStrategy;
readonly workflow: Workflow | null;
createCollection(name: string, requester?: Collection<CollectionMetadataT, SchematicMetadataT>): Collection<CollectionMetadataT, SchematicMetadataT>;
createContext(schematic: Schematic<CollectionMetadataT, SchematicMetadataT>, parent?: Partial<TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>>, executionOptions?: Partial<ExecutionOptions>): TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>;
createSchematic(name: string, collection: Collection<CollectionMetadataT, SchematicMetadataT>): Schematic<CollectionMetadataT, SchematicMetadataT>;
createSourceFromUrl(url: Url, context: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>): Source;
executePostTasks(): Observable<void>;
transformOptions<OptionT extends object, ResultT extends object>(schematic: Schematic<CollectionMetadataT, SchematicMetadataT>, options: OptionT, context?: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>): Observable<ResultT>;
}
export interface EngineHost<CollectionMetadataT extends object, SchematicMetadataT extends object> {
readonly defaultMergeStrategy?: MergeStrategy;
createCollectionDescription(name: string, requester?: CollectionDescription<CollectionMetadataT>): CollectionDescription<CollectionMetadataT>;
createSchematicDescription(name: string, collection: CollectionDescription<CollectionMetadataT>): SchematicDescription<CollectionMetadataT, SchematicMetadataT> | null;
createSourceFromUrl(url: Url, context: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>): Source | null;
createTaskExecutor(name: string): Observable<TaskExecutor>;
getSchematicRuleFactory<OptionT extends object>(schematic: SchematicDescription<CollectionMetadataT, SchematicMetadataT>, collection: CollectionDescription<CollectionMetadataT>): RuleFactory<OptionT>;
hasTaskExecutor(name: string): boolean;
listSchematicNames(collection: CollectionDescription<CollectionMetadataT>): string[];
transformContext(context: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>): TypedSchematicContext<CollectionMetadataT, SchematicMetadataT> | void;
transformOptions<OptionT extends object, ResultT extends object>(schematic: SchematicDescription<CollectionMetadataT, SchematicMetadataT>, options: OptionT, context?: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>): Observable<ResultT>;
}
export interface ExecutionOptions {
interactive: boolean;
scope: string;
}
export declare function externalSchematic<OptionT extends object>(collectionName: string, schematicName: string, options: OptionT, executionOptions?: Partial<ExecutionOptions>): Rule;
export declare class FileAlreadyExistException extends BaseException {
constructor(path: string);
}
export declare class FileDoesNotExistException extends BaseException {
constructor(path: string);
}
export interface FileEntry {
readonly content: Buffer;
readonly path: Path;
}
export declare type FileOperator = (entry: FileEntry) => FileEntry | null;
export interface FilePredicate<T> {
(path: Path, entry?: Readonly<FileEntry> | null): T;
}
export declare type FileVisitor = FilePredicate<void>;
export declare const FileVisitorCancelToken: symbol;
export declare function filter(predicate: FilePredicate<boolean>): Rule;
export declare class FilterHostTree extends HostTree {
constructor(tree: HostTree, filter?: FilePredicate<boolean>);
}
export declare function forEach(operator: FileOperator): Rule;
export declare class HostCreateTree extends HostTree {
constructor(host: virtualFs.ReadonlyHost);
}
export declare class HostDirEntry implements DirEntry {
protected _host: virtualFs.SyncDelegateHost;
protected _tree: Tree;
readonly parent: DirEntry | null;
readonly path: Path;
get subdirs(): PathFragment[];
get subfiles(): PathFragment[];
constructor(parent: DirEntry | null, path: Path, _host: virtualFs.SyncDelegateHost, _tree: Tree);
dir(name: PathFragment): DirEntry;
file(name: PathFragment): FileEntry | null;
visit(visitor: FileVisitor): void;
}
export declare class HostSink extends SimpleSinkBase {
protected _filesToCreate: Map<Path, UpdateBuffer>;
protected _filesToDelete: Set<Path>;
protected _filesToRename: Set<[Path, Path]>;
protected _filesToUpdate: Map<Path, UpdateBuffer>;
protected _force: boolean;
protected _host: virtualFs.Host;
constructor(_host: virtualFs.Host, _force?: boolean);
protected _createFile(path: Path, content: Buffer): Observable<void>;
protected _deleteFile(path: Path): Observable<void>;
_done(): Observable<void>;
protected _overwriteFile(path: Path, content: Buffer): Observable<void>;
protected _renameFile(from: Path, to: Path): Observable<void>;
protected _validateCreateAction(action: CreateFileAction): Observable<void>;
protected _validateFileExists(p: Path): Observable<boolean>;
}
export declare class HostTree implements Tree {
protected _backend: virtualFs.ReadonlyHost<{}>;
get actions(): Action[];
get root(): DirEntry;
constructor(_backend?: virtualFs.ReadonlyHost<{}>);
protected _normalizePath(path: string): Path;
protected _willCreate(path: Path): boolean;
protected _willDelete(path: Path): boolean;
protected _willOverwrite(path: Path): boolean;
protected _willRename(path: Path): boolean;
apply(action: Action, strategy?: MergeStrategy): void;
beginUpdate(path: string): UpdateRecorder;
branch(): Tree;
commitUpdate(record: UpdateRecorder): void;
create(path: string, content: Buffer | string): void;
delete(path: string): void;
exists(path: string): boolean;
get(path: string): FileEntry | null;
getDir(path: string): DirEntry;
merge(other: Tree, strategy?: MergeStrategy): void;
overwrite(path: string, content: Buffer | string): void;
read(path: string): Buffer | null;
rename(from: string, to: string): void;
visit(visitor: FileVisitor): void;
static isHostTree(tree: Tree): tree is HostTree;
}
export declare const htmlSelectorFormat: schema.SchemaFormat;
export declare class InvalidPipeException extends BaseException {
constructor(name: string);
}
export declare class InvalidRuleResultException extends BaseException {
constructor(value?: {});
}
export declare class InvalidSchematicsNameException extends BaseException {
constructor(name: string);
}
export declare class InvalidSourceResultException extends BaseException {
constructor(value?: {});
}
export declare class InvalidUpdateRecordException extends BaseException {
constructor();
}
export declare function isAction(action: any): action is Action;
export declare function isContentAction(action: Action): action is CreateFileAction | OverwriteFileAction;
export interface LifeCycleEvent {
kind: 'start' | 'end' | 'workflow-start' | 'workflow-end' | 'post-tasks-start' | 'post-tasks-end';
}
export declare class MergeConflictException extends BaseException {
constructor(path: string);
}
export declare enum MergeStrategy {
AllowOverwriteConflict = 2,
AllowCreationConflict = 4,
AllowDeleteConflict = 8,
Default = 0,
Error = 1,
ContentOnly = 2,
Overwrite = 14
}
export declare function mergeWith(source: Source, strategy?: MergeStrategy): Rule;
export declare function move(from: string, to?: string): Rule;
export declare function noop(): Rule;
export declare class OptionIsNotDefinedException extends BaseException {
constructor(name: string);
}
export interface OverwriteFileAction extends ActionBase {
readonly content: Buffer;
readonly kind: 'o';
}
export declare function partitionApplyMerge(predicate: FilePredicate<boolean>, ruleYes: Rule, ruleNo?: Rule): Rule;
export declare const pathFormat: schema.SchemaFormat;
export declare function pathTemplate<T extends PathTemplateData>(options: T): Rule;
export declare type PathTemplateData = {
[key: string]: PathTemplateValue | PathTemplateData | PathTemplatePipeFunction;
};
export interface PathTemplateOptions {
interpolationEnd: string;
interpolationStart: string;
pipeSeparator?: string;
}
export declare type PathTemplatePipeFunction = (x: string) => PathTemplateValue;
export declare type PathTemplateValue = boolean | string | number | undefined;
export declare class PrivateSchematicException extends BaseException {
constructor(name: string, collection: CollectionDescription<{}>);
}
export interface RandomOptions {
multi?: boolean | number;
multiFiles?: boolean | number;
root?: string;
}
export interface RenameFileAction extends ActionBase {
readonly kind: 'r';
readonly to: Path;
}
export declare function renameTemplateFiles(): Rule;
export interface RequiredWorkflowExecutionContext {
collection: string;
options: object;
schematic: string;
}
export declare type Rule = (tree: Tree, context: SchematicContext) => Tree | Observable<Tree> | Rule | Promise<void | Rule> | void;
export declare type RuleFactory<T extends object> = (options: T) => Rule;
export declare function schematic<OptionT extends object>(schematicName: string, options: OptionT, executionOptions?: Partial<ExecutionOptions>): Rule;
export interface Schematic<CollectionMetadataT extends object, SchematicMetadataT extends object> {
readonly collection: Collection<CollectionMetadataT, SchematicMetadataT>;
readonly description: SchematicDescription<CollectionMetadataT, SchematicMetadataT>;
call<OptionT extends object>(options: OptionT, host: Observable<Tree>, parentContext?: Partial<TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>>, executionOptions?: Partial<ExecutionOptions>): Observable<Tree>;
}
export declare type SchematicContext = TypedSchematicContext<{}, {}>;
export declare type SchematicDescription<CollectionMetadataT extends object, SchematicMetadataT extends object> = SchematicMetadataT & {
readonly collection: CollectionDescription<CollectionMetadataT>;
readonly name: string;
readonly private?: boolean;
readonly hidden?: boolean;
};
export declare class SchematicEngine<CollectionT extends object, SchematicT extends object> implements Engine<CollectionT, SchematicT> {
protected _workflow?: Workflow | undefined;
get defaultMergeStrategy(): MergeStrategy;
get workflow(): Workflow | null;
constructor(_host: EngineHost<CollectionT, SchematicT>, _workflow?: Workflow | undefined);
createCollection(name: string, requester?: Collection<CollectionT, SchematicT>): Collection<CollectionT, SchematicT>;
createContext(schematic: Schematic<CollectionT, SchematicT>, parent?: Partial<TypedSchematicContext<CollectionT, SchematicT>>, executionOptions?: Partial<ExecutionOptions>): TypedSchematicContext<CollectionT, SchematicT>;
createSchematic(name: string, collection: Collection<CollectionT, SchematicT>, allowPrivate?: boolean): Schematic<CollectionT, SchematicT>;
createSourceFromUrl(url: Url, context: TypedSchematicContext<CollectionT, SchematicT>): Source;
executePostTasks(): Observable<void>;
listSchematicNames(collection: Collection<CollectionT, SchematicT>): string[];
transformOptions<OptionT extends object, ResultT extends object>(schematic: Schematic<CollectionT, SchematicT>, options: OptionT, context?: TypedSchematicContext<CollectionT, SchematicT>): Observable<ResultT>;
}
export declare class SchematicEngineConflictingException extends BaseException {
constructor();
}
export declare class SchematicImpl<CollectionT extends object, SchematicT extends object> implements Schematic<CollectionT, SchematicT> {
get collection(): Collection<CollectionT, SchematicT>;
get description(): SchematicDescription<CollectionT, SchematicT>;
constructor(_description: SchematicDescription<CollectionT, SchematicT>, _factory: RuleFactory<{}>, _collection: Collection<CollectionT, SchematicT>, _engine: Engine<CollectionT, SchematicT>);
call<OptionT extends object>(options: OptionT, host: Observable<Tree>, parentContext?: Partial<TypedSchematicContext<CollectionT, SchematicT>>, executionOptions?: Partial<ExecutionOptions>): Observable<Tree>;
}
export declare class SchematicsException extends BaseException {
}
export declare abstract class SimpleSinkBase implements Sink {
postCommit: () => void | Observable<void>;
postCommitAction: (action: Action) => void | Observable<void>;
preCommit: () => void | Observable<void>;
preCommitAction: (action: Action) => void | Action | PromiseLike<Action> | Observable<Action>;
protected abstract _createFile(path: string, content: Buffer): Observable<void>;
protected abstract _deleteFile(path: string): Observable<void>;
protected abstract _done(): Observable<void>;
protected _fileAlreadyExistException(path: string): void;
protected _fileDoesNotExistException(path: string): void;
protected abstract _overwriteFile(path: string, content: Buffer): Observable<void>;
protected abstract _renameFile(path: string, to: string): Observable<void>;
protected _validateCreateAction(action: CreateFileAction): Observable<void>;
protected _validateDeleteAction(action: DeleteFileAction): Observable<void>;
protected abstract _validateFileExists(p: string): Observable<boolean>;
protected _validateOverwriteAction(action: OverwriteFileAction): Observable<void>;
protected _validateRenameAction(action: RenameFileAction): Observable<void>;
commit(tree: Tree): Observable<void>;
commitSingleAction(action: Action): Observable<void>;
validateSingleAction(action: Action): Observable<void>;
}
export interface Sink {
commit(tree: Tree): Observable<void>;
}
export declare function source(tree: Tree): Source;
export declare type Source = (context: SchematicContext) => Tree | Observable<Tree>;
export declare const standardFormats: schema.SchemaFormat[];
export interface TaskConfiguration<T = {}> {
dependencies?: Array<TaskId>;
name: string;
options?: T;
}
export interface TaskConfigurationGenerator<T = {}> {
toConfiguration(): TaskConfiguration<T>;
}
export declare type TaskExecutor<T = {}> = (options: T | undefined, context: SchematicContext) => Promise<void> | Observable<void>;
export interface TaskExecutorFactory<T> {
readonly name: string;
create(options?: T): Promise<TaskExecutor> | Observable<TaskExecutor>;
}
export interface TaskId {
readonly id: number;
}
export interface TaskInfo {
readonly configuration: TaskConfiguration;
readonly context: SchematicContext;
readonly id: number;
readonly priority: number;
}
export declare class TaskScheduler {
constructor(_context: SchematicContext);
finalize(): ReadonlyArray<TaskInfo>;
schedule<T>(taskConfiguration: TaskConfiguration<T>): TaskId;
}
export declare function template<T>(options: T): Rule;
export declare const TEMPLATE_FILENAME_RE: RegExp;
export declare type Tree = TreeInterface;
export interface TreeConstructor {
branch(tree: TreeInterface): TreeInterface;
empty(): TreeInterface;
merge(tree: TreeInterface, other: TreeInterface, strategy?: MergeStrategy): TreeInterface;
optimize(tree: TreeInterface): TreeInterface;
partition(tree: TreeInterface, predicate: FilePredicate<boolean>): [TreeInterface, TreeInterface];
}
export declare const TreeSymbol: symbol;
export interface TypedSchematicContext<CollectionMetadataT extends object, SchematicMetadataT extends object> {
readonly analytics?: analytics.Analytics;
readonly debug: boolean;
readonly engine: Engine<CollectionMetadataT, SchematicMetadataT>;
readonly interactive: boolean;
readonly logger: logging.LoggerApi;
readonly schematic: Schematic<CollectionMetadataT, SchematicMetadataT>;
readonly strategy: MergeStrategy;
addTask<T>(task: TaskConfigurationGenerator<T>, dependencies?: Array<TaskId>): TaskId;
}
export declare class UnimplementedException extends BaseException {
constructor();
}
export declare class UnknownActionException extends BaseException {
constructor(action: Action);
}
export declare class UnknownCollectionException extends BaseException {
constructor(name: string);
}
export declare class UnknownPipeException extends BaseException {
constructor(name: string);
}
export declare class UnknownSchematicException extends BaseException {
constructor(name: string, collection: CollectionDescription<{}>);
}
export declare class UnknownTaskDependencyException extends BaseException {
constructor(id: TaskId);
}
export declare class UnknownUrlSourceProtocol extends BaseException {
constructor(url: string);
}
export declare class UnregisteredTaskException extends BaseException {
constructor(name: string, schematic?: SchematicDescription<{}, {}>);
}
export declare class UnsuccessfulWorkflowExecution extends BaseException {
constructor();
}
export interface UpdateRecorder {
insertLeft(index: number, content: Buffer | string): UpdateRecorder;
insertRight(index: number, content: Buffer | string): UpdateRecorder;
remove(index: number, length: number): UpdateRecorder;
}
export declare function url(urlString: string): Source;
export declare function when(predicate: FilePredicate<boolean>, operator: FileOperator): FileOperator;
export interface Workflow {
readonly context: Readonly<WorkflowExecutionContext>;
execute(options: Partial<WorkflowExecutionContext> & RequiredWorkflowExecutionContext): Observable<void>;
}
export interface WorkflowExecutionContext extends RequiredWorkflowExecutionContext {
allowPrivate?: boolean;
debug: boolean;
logger: logging.Logger;
parentContext?: Readonly<WorkflowExecutionContext>;
}

1044
goldens/public-api/angular_devkit/schematics/src/index.md Normal file
View File

File diff suppressed because it is too large Load Diff

89
goldens/public-api/angular_devkit/schematics/tasks/index.d.ts → goldens/public-api/angular_devkit/schematics/tasks/index.md
View File

@ -1,43 +1,80 @@
export declare class NodePackageInstallTask implements TaskConfigurationGenerator<NodePackageTaskOptions> {
hideOutput: boolean;
packageManager?: string;
packageName?: string;
quiet: boolean;
workingDirectory?: string;
constructor(options: NodePackageInstallTaskOptions);
## API Report File for "@angular-devkit/schematics_tasks"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { JsonObject } from '@angular-devkit/core';
// @public (undocumented)
export class NodePackageInstallTask implements TaskConfigurationGenerator<NodePackageTaskOptions> {
constructor(workingDirectory?: string);
toConfiguration(): TaskConfiguration<NodePackageTaskOptions>;
}
export declare class NodePackageLinkTask implements TaskConfigurationGenerator<NodePackageTaskOptions> {
packageName?: string | undefined;
constructor(options: NodePackageInstallTaskOptions);
// (undocumented)
hideOutput: boolean;
// (undocumented)
packageManager?: string;
// (undocumented)
packageName?: string;
// (undocumented)
quiet: boolean;
workingDirectory?: string | undefined;
constructor(packageName?: string | undefined, workingDirectory?: string | undefined);
// (undocumented)
toConfiguration(): TaskConfiguration<NodePackageTaskOptions>;
// (undocumented)
workingDirectory?: string;
}
export declare class RepositoryInitializerTask implements TaskConfigurationGenerator<RepositoryInitializerTaskOptions> {
commitOptions?: CommitOptions | undefined;
// @public (undocumented)
export class NodePackageLinkTask implements TaskConfigurationGenerator<NodePackageTaskOptions> {
constructor(packageName?: string | undefined, workingDirectory?: string | undefined);
// (undocumented)
packageName?: string | undefined;
// (undocumented)
quiet: boolean;
// (undocumented)
toConfiguration(): TaskConfiguration<NodePackageTaskOptions>;
// (undocumented)
workingDirectory?: string | undefined;
constructor(workingDirectory?: string | undefined, commitOptions?: CommitOptions | undefined);
toConfiguration(): TaskConfiguration<RepositoryInitializerTaskOptions>;
}
export declare class RunSchematicTask<T> implements TaskConfigurationGenerator<RunSchematicTaskOptions<T>> {
protected _collection: string | null;
protected _options: T;
protected _schematic: string;
constructor(c: string, s: string, o: T);
// @public (undocumented)
export class RepositoryInitializerTask implements TaskConfigurationGenerator<RepositoryInitializerTaskOptions> {
constructor(workingDirectory?: string | undefined, commitOptions?: CommitOptions | undefined);
// (undocumented)
commitOptions?: CommitOptions | undefined;
// (undocumented)
toConfiguration(): TaskConfiguration<RepositoryInitializerTaskOptions>;
// (undocumented)
workingDirectory?: string | undefined;
}
// @public (undocumented)
export class RunSchematicTask<T> implements TaskConfigurationGenerator<RunSchematicTaskOptions<T>> {
constructor(s: string, o: T);
constructor(c: string, s: string, o: T);
// (undocumented)
protected _collection: string | null;
// (undocumented)
protected _options: T;
// (undocumented)
protected _schematic: string;
// (undocumented)
toConfiguration(): TaskConfiguration<RunSchematicTaskOptions<T>>;
}
export declare class TslintFixTask implements TaskConfigurationGenerator<TslintFixTaskOptions> {
protected _configOrPath: null | string | JsonObject;
protected _options: TslintFixTaskOptionsBase;
// @public @deprecated (undocumented)
export class TslintFixTask implements TaskConfigurationGenerator<TslintFixTaskOptions> {
constructor(config: JsonObject, options: TslintFixTaskOptionsBase);
constructor(options: TslintFixTaskOptionsBase);
constructor(path: string, options: TslintFixTaskOptionsBase);
// (undocumented)
protected _configOrPath: null | string | JsonObject;
// (undocumented)
protected _options: TslintFixTaskOptionsBase;
// (undocumented)
toConfiguration(): TaskConfiguration<TslintFixTaskOptions>;
}
// (No @packageDocumentation comment for this package)
```

15
goldens/public-api/angular_devkit/schematics/testing/index.d.ts vendored
View File

@ -1,15 +0,0 @@
export declare class SchematicTestRunner {
get engine(): SchematicEngine<{}, {}>;
get logger(): logging.Logger;
get tasks(): TaskConfiguration[];
constructor(_collectionName: string, collectionPath: string);
callRule(rule: Rule, tree: Tree, parentContext?: Partial<SchematicContext>): Observable<Tree>;
registerCollection(collectionName: string, collectionPath: string): void;
runExternalSchematicAsync<SchematicSchemaT>(collectionName: string, schematicName: string, opts?: SchematicSchemaT, tree?: Tree): Observable<UnitTestTree>;
runSchematicAsync<SchematicSchemaT>(schematicName: string, opts?: SchematicSchemaT, tree?: Tree): Observable<UnitTestTree>;
}
export declare class UnitTestTree extends DelegateTree {
get files(): string[];
readContent(path: string): string;
}

43
goldens/public-api/angular_devkit/schematics/testing/index.md Normal file
View File

@ -0,0 +1,43 @@
## API Report File for "@angular-devkit/schematics_testing"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { analytics } from '@angular-devkit/core';
import { logging } from '@angular-devkit/core';
import { Observable } from 'rxjs';
import { Path } from '@angular-devkit/core';
import { PathFragment } from '@angular-devkit/core';
import { Url } from 'url';
// @public (undocumented)
export class SchematicTestRunner {
constructor(_collectionName: string, collectionPath: string);
// (undocumented)
callRule(rule: Rule, tree: Tree_2, parentContext?: Partial<SchematicContext>): Observable<Tree_2>;
// (undocumented)
get engine(): SchematicEngine<{}, {}>;
// (undocumented)
get logger(): logging.Logger;
// (undocumented)
registerCollection(collectionName: string, collectionPath: string): void;
// (undocumented)
runExternalSchematicAsync<SchematicSchemaT>(collectionName: string, schematicName: string, opts?: SchematicSchemaT, tree?: Tree_2): Observable<UnitTestTree>;
// (undocumented)
runSchematicAsync<SchematicSchemaT>(schematicName: string, opts?: SchematicSchemaT, tree?: Tree_2): Observable<UnitTestTree>;
// (undocumented)
get tasks(): TaskConfiguration[];
}
// @public (undocumented)
export class UnitTestTree extends DelegateTree {
// (undocumented)
get files(): string[];
// (undocumented)
readContent(path: string): string;
}
// (No @packageDocumentation comment for this package)
```

210
goldens/public-api/angular_devkit/schematics/tools/index.d.ts → goldens/public-api/angular_devkit/schematics/tools/index.md
View File

@ -1,166 +1,282 @@
export declare class CollectionCannotBeResolvedException extends BaseException {
## API Report File for "@angular-devkit/schematics_tools"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
/// <reference types="node" />
import { analytics } from '@angular-devkit/core';
import { BaseException } from '@angular-devkit/core';
import { InvalidJsonCharacterException } from '@angular-devkit/core';
import { JsonObject } from '@angular-devkit/core';
import { logging } from '@angular-devkit/core';
import { Observable } from 'rxjs';
import { Path } from '@angular-devkit/core';
import { PathFragment } from '@angular-devkit/core';
import { schema } from '@angular-devkit/core';
import { UnexpectedEndOfInputException } from '@angular-devkit/core';
import { Url } from 'url';
import { virtualFs } from '@angular-devkit/core';
import { workflow } from '@angular-devkit/schematics';
// @public (undocumented)
export class CollectionCannotBeResolvedException extends BaseException {
constructor(name: string);
}
export declare class CollectionMissingFieldsException extends BaseException {
// @public (undocumented)
export class CollectionMissingFieldsException extends BaseException {
constructor(name: string);
}
export declare class CollectionMissingSchematicsMapException extends BaseException {
// @public (undocumented)
export class CollectionMissingSchematicsMapException extends BaseException {
constructor(name: string);
}
export declare type ContextTransform = (context: FileSystemSchematicContext) => FileSystemSchematicContext;
// @public (undocumented)
export type ContextTransform = (context: FileSystemSchematicContext) => FileSystemSchematicContext;
export declare class ExportStringRef<T> {
get module(): string;
get path(): string;
get ref(): T | undefined;
// @public
export class ExportStringRef<T> {
constructor(ref: string, parentPath?: string, inner?: boolean);
// (undocumented)
get module(): string;
// (undocumented)
get path(): string;
// (undocumented)
get ref(): T | undefined;
}
export declare class FactoryCannotBeResolvedException extends BaseException {
// @public (undocumented)
export class FactoryCannotBeResolvedException extends BaseException {
constructor(name: string);
}
export declare type FileSystemCollection = Collection<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public (undocumented)
export type FileSystemCollection = Collection<FileSystemCollectionDescription, FileSystemSchematicDescription>;
export declare type FileSystemCollectionDesc = CollectionDescription<FileSystemCollectionDescription>;
// @public (undocumented)
export type FileSystemCollectionDesc = CollectionDescription<FileSystemCollectionDescription>;
// @public (undocumented)
export interface FileSystemCollectionDescription {
// (undocumented)
readonly name: string;
// (undocumented)
readonly path: string;
// (undocumented)
readonly schematics: {
[name: string]: FileSystemSchematicDesc;
};
// (undocumented)
readonly version?: string;
}
export declare type FileSystemEngine = Engine<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public
export type FileSystemEngine = Engine<FileSystemCollectionDescription, FileSystemSchematicDescription>;
export declare class FileSystemEngineHost extends FileSystemEngineHostBase {
protected _root: string;
// @public
export class FileSystemEngineHost extends FileSystemEngineHostBase {
constructor(_root: string);
// (undocumented)
createTaskExecutor(name: string): Observable<TaskExecutor>;
// (undocumented)
hasTaskExecutor(name: string): boolean;
// (undocumented)
protected _resolveCollectionPath(name: string): string;
// (undocumented)
protected _resolveReferenceString(refString: string, parentPath: string): {
ref: RuleFactory<{}>;
path: string;
} | null;
// (undocumented)
protected _root: string;
// (undocumented)
protected _transformCollectionDescription(name: string, desc: Partial<FileSystemCollectionDesc>): FileSystemCollectionDesc;
// (undocumented)
protected _transformSchematicDescription(name: string, _collection: FileSystemCollectionDesc, desc: Partial<FileSystemSchematicDesc>): FileSystemSchematicDesc;
createTaskExecutor(name: string): Observable<TaskExecutor>;
hasTaskExecutor(name: string): boolean;
}
export declare abstract class FileSystemEngineHostBase implements FileSystemEngineHost {
// @public
export abstract class FileSystemEngineHostBase implements FileSystemEngineHost_2 {
// (undocumented)
createCollectionDescription(name: string, requester?: FileSystemCollectionDesc): FileSystemCollectionDesc;
// (undocumented)
createSchematicDescription(name: string, collection: FileSystemCollectionDesc): FileSystemSchematicDesc | null;
// (undocumented)
createSourceFromUrl(url: Url): Source | null;
// (undocumented)
createTaskExecutor(name: string): Observable<TaskExecutor>;
// (undocumented)
getSchematicRuleFactory<OptionT extends object>(schematic: FileSystemSchematicDesc, _collection: FileSystemCollectionDesc): RuleFactory<OptionT>;
// (undocumented)
hasTaskExecutor(name: string): boolean;
// (undocumented)
listSchematicNames(collection: FileSystemCollectionDesc): string[];
// (undocumented)
registerContextTransform(t: ContextTransform): void;
// (undocumented)
registerOptionsTransform<T extends object, R extends object>(t: OptionTransform<T, R>): void;
// (undocumented)
registerTaskExecutor<T>(factory: TaskExecutorFactory<T>, options?: T): void;
// (undocumented)
protected abstract _resolveCollectionPath(name: string, requester?: string): string;
// (undocumented)
protected abstract _resolveReferenceString(name: string, parentPath: string): {
ref: RuleFactory<{}>;
path: string;
} | null;
// (undocumented)
protected abstract _transformCollectionDescription(name: string, desc: Partial<FileSystemCollectionDesc>): FileSystemCollectionDesc;
protected abstract _transformSchematicDescription(name: string, collection: FileSystemCollectionDesc, desc: Partial<FileSystemSchematicDesc>): FileSystemSchematicDesc;
createCollectionDescription(name: string, requester?: FileSystemCollectionDesc): FileSystemCollectionDesc;
createSchematicDescription(name: string, collection: FileSystemCollectionDesc): FileSystemSchematicDesc | null;
createSourceFromUrl(url: Url): Source | null;
createTaskExecutor(name: string): Observable<TaskExecutor>;
getSchematicRuleFactory<OptionT extends object>(schematic: FileSystemSchematicDesc, _collection: FileSystemCollectionDesc): RuleFactory<OptionT>;
hasTaskExecutor(name: string): boolean;
listSchematicNames(collection: FileSystemCollectionDesc): string[];
registerContextTransform(t: ContextTransform): void;
registerOptionsTransform<T extends object, R extends object>(t: OptionTransform<T, R>): void;
registerTaskExecutor<T>(factory: TaskExecutorFactory<T>, options?: T): void;
// (undocumented)
transformContext(context: FileSystemSchematicContext): FileSystemSchematicContext;
// (undocumented)
transformOptions<OptionT extends object, ResultT extends object>(schematic: FileSystemSchematicDesc, options: OptionT, context?: FileSystemSchematicContext): Observable<ResultT>;
// (undocumented)
protected abstract _transformSchematicDescription(name: string, collection: FileSystemCollectionDesc, desc: Partial<FileSystemSchematicDesc>): FileSystemSchematicDesc;
}
export declare type FileSystemSchematic = Schematic<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public (undocumented)
export type FileSystemSchematic = Schematic<FileSystemCollectionDescription, FileSystemSchematicDescription>;
export declare type FileSystemSchematicContext = TypedSchematicContext<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public (undocumented)
export type FileSystemSchematicContext = TypedSchematicContext<FileSystemCollectionDescription, FileSystemSchematicDescription>;
export declare type FileSystemSchematicDesc = SchematicDescription<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public (undocumented)
export type FileSystemSchematicDesc = SchematicDescription<FileSystemCollectionDescription, FileSystemSchematicDescription>;
// @public (undocumented)
export interface FileSystemSchematicDescription extends FileSystemSchematicJsonDescription {
// (undocumented)
readonly factoryFn: RuleFactory<{}>;
// (undocumented)
readonly path: string;
// (undocumented)
readonly schemaJson?: JsonObject;
}
// @public (undocumented)
export interface FileSystemSchematicJsonDescription {
// (undocumented)
readonly aliases?: string[];
// (undocumented)
readonly collection: FileSystemCollectionDescription;
// (undocumented)
readonly description: string;
// (undocumented)
readonly extends?: string;
// (undocumented)
readonly factory: string;
// (undocumented)
readonly name: string;
// (undocumented)
readonly schema?: string;
}
export declare class InvalidCollectionJsonException extends BaseException {
// @public (undocumented)
export class InvalidCollectionJsonException extends BaseException {
constructor(_name: string, path: string, jsonException?: UnexpectedEndOfInputException | InvalidJsonCharacterException);
}
export declare class NodeModulesEngineHost extends FileSystemEngineHostBase {
// @public
export class NodeModulesEngineHost extends FileSystemEngineHostBase {
constructor(paths?: string[] | undefined);
// (undocumented)
protected _resolveCollectionPath(name: string, requester?: string): string;
// (undocumented)
protected _resolveReferenceString(refString: string, parentPath: string): {
ref: RuleFactory<{}>;
path: string;
} | null;
// (undocumented)
protected _transformCollectionDescription(name: string, desc: Partial<FileSystemCollectionDesc>): FileSystemCollectionDesc;
// (undocumented)
protected _transformSchematicDescription(name: string, _collection: FileSystemCollectionDesc, desc: Partial<FileSystemSchematicDesc>): FileSystemSchematicDesc;
}
export declare class NodeModulesTestEngineHost extends NodeModulesEngineHost {
get tasks(): TaskConfiguration<{}>[];
protected _resolveCollectionPath(name: string, requester?: string): string;
// @public
export class NodeModulesTestEngineHost extends NodeModulesEngineHost {
// (undocumented)
clearTasks(): void;
// (undocumented)
registerCollection(name: string, path: string): void;
// (undocumented)
protected _resolveCollectionPath(name: string, requester?: string): string;
// (undocumented)
get tasks(): TaskConfiguration<{}>[];
// (undocumented)
transformContext(context: FileSystemSchematicContext): FileSystemSchematicContext;
}
export declare class NodePackageDoesNotSupportSchematics extends BaseException {
// @public (undocumented)
export class NodePackageDoesNotSupportSchematics extends BaseException {
constructor(name: string);
}
export declare class NodeWorkflow extends workflow.BaseWorkflow {
get engine(): FileSystemEngine;
get engineHost(): NodeModulesEngineHost;
// @public
export class NodeWorkflow extends workflow.BaseWorkflow {
constructor(root: string, options: NodeWorkflowOptions);
constructor(host: virtualFs.Host, options: NodeWorkflowOptions & {
root?: Path;
});
constructor(root: string, options: NodeWorkflowOptions);
// (undocumented)
get engine(): FileSystemEngine;
// (undocumented)
get engineHost(): NodeModulesEngineHost;
}
// @public (undocumented)
export interface NodeWorkflowOptions {
// (undocumented)
dryRun?: boolean;
// (undocumented)
engineHostCreator?: (options: NodeWorkflowOptions) => NodeModulesEngineHost;
// (undocumented)
force?: boolean;
// (undocumented)
optionTransforms?: OptionTransform<object, object>[];
// (undocumented)
packageManager?: string;
// (undocumented)
packageManagerForce?: boolean;
// (undocumented)
packageRegistry?: string;
// (undocumented)
registry?: schema.CoreSchemaRegistry;
// (undocumented)
resolvePaths?: string[];
// (undocumented)
schemaValidation?: boolean;
}
export declare type OptionTransform<T extends object, R extends object> = (schematic: FileSystemSchematicDescription, options: T, context?: FileSystemSchematicContext) => Observable<R> | PromiseLike<R> | R;
// @public (undocumented)
export type OptionTransform<T extends object, R extends object> = (schematic: FileSystemSchematicDescription, options: T, context?: FileSystemSchematicContext) => Observable<R> | PromiseLike<R> | R;
export declare class SchematicMissingDescriptionException extends BaseException {
// @public (undocumented)
export class SchematicMissingDescriptionException extends BaseException {
constructor(name: string);
}
export declare class SchematicMissingFactoryException extends BaseException {
// @public (undocumented)
export class SchematicMissingFactoryException extends BaseException {
constructor(name: string);
}
export declare class SchematicMissingFieldsException extends BaseException {
// @public (undocumented)
export class SchematicMissingFieldsException extends BaseException {
constructor(name: string);
}
export declare class SchematicNameCollisionException extends BaseException {
// @public (undocumented)
export class SchematicNameCollisionException extends BaseException {
constructor(name: string);
}
export declare function validateOptionsWithSchema(registry: schema.SchemaRegistry): <T extends {}>(schematic: FileSystemSchematicDescription, options: T, context?: FileSystemSchematicContext | undefined) => Observable<T>;
// @public (undocumented)
export function validateOptionsWithSchema(registry: schema.SchemaRegistry): <T extends {}>(schematic: FileSystemSchematicDescription, options: T, context?: FileSystemSchematicContext | undefined) => Observable<T>;
// (No @packageDocumentation comment for this package)
```

54
goldens/public-api/manage.js Normal file
View File

@ -0,0 +1,54 @@
const {exec} = require('shelljs');
const minimist = require('minimist');
// Remove all command line flags from the arguments.
const argv = minimist(process.argv.slice(2));
// The command the user would like to run, either 'accept' or 'test'
const USER_COMMAND = argv._[0];
// The shell command to query for all Public API guard tests.
const BAZEL_PUBLIC_API_TARGET_QUERY_CMD =
`yarn -s bazel query --output label 'kind(nodejs_test, ...) intersect attr("tags", "api_guard", ...)'`
// Bazel targets for testing Public API goldens
process.stdout.write('Gathering all Public API targets');
const ALL_PUBLIC_API_TESTS = exec(BAZEL_PUBLIC_API_TARGET_QUERY_CMD, {silent: true})
.trim()
.split('\n')
.map(test => test.trim());
process.stdout.clearLine();
process.stdout.cursorTo(0);
// Bazel targets for generating Public API goldens
const ALL_PUBLIC_API_ACCEPTS = ALL_PUBLIC_API_TESTS.map(test => `${test}.accept`);
/**
* Run the provided bazel commands on each provided target individually.
*/
function runBazelCommandOnTargets(command, targets, present) {
for (const target of targets) {
process.stdout.write(`${present}: ${target}`);
const commandResult = exec(`yarn -s bazel ${command} ${target}`, {silent: true});
process.stdout.clearLine();
process.stdout.cursorTo(0);
if (commandResult.code) {
console.error(`Failed ${command}: ${target}`);
console.group();
console.error(commandResult.stdout || commandResult.stderr);
console.groupEnd();
} else {
console.log(`Successful ${command}: ${target}`);
}
}
}
switch (USER_COMMAND) {
case 'accept':
runBazelCommandOnTargets('run', ALL_PUBLIC_API_ACCEPTS, 'Running');
break;
case 'test':
runBazelCommandOnTargets('test', ALL_PUBLIC_API_TESTS, 'Testing');
break;
default:
console.warn('Invalid command provided.');
console.warn();
console.warn(`Run this script with either "accept" and "test"`);
break;
}

65
goldens/public-api/ngtools/webpack/src/index.md Normal file
View File

@ -0,0 +1,65 @@
## API Report File for "@ngtools/webpack"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import type { Compiler } from 'webpack';
import { CompilerOptions } from '@angular/compiler-cli';
import type { LoaderContext } from 'webpack';
// @public (undocumented)
function angularWebpackLoader(this: LoaderContext<unknown>, content: string, map: string): void;
export default angularWebpackLoader;
// @public (undocumented)
export const AngularWebpackLoaderPath: string;
// @public (undocumented)
export class AngularWebpackPlugin {
constructor(options?: Partial<AngularWebpackPluginOptions>);
// (undocumented)
apply(compiler: Compiler): void;
// (undocumented)
get options(): AngularWebpackPluginOptions;
}
// @public (undocumented)
export interface AngularWebpackPluginOptions {
// (undocumented)
compilerOptions?: CompilerOptions;
// (undocumented)
directTemplateLoading: boolean;
// (undocumented)
emitClassMetadata: boolean;
// (undocumented)
emitNgModuleScope: boolean;
// (undocumented)
fileReplacements: Record<string, string>;
// (undocumented)
inlineStyleFileExtension?: string;
// @deprecated (undocumented)
inlineStyleMimeType?: string;
// (undocumented)
jitMode: boolean;
// (undocumented)
substitutions: Record<string, string>;
// (undocumented)
tsconfig: string;
}
// @public @deprecated (undocumented)
export namespace ivy {
const // (undocumented)
AngularWebpackLoaderPath: string;
const // (undocumented)
AngularWebpackPlugin: typeof ivyInternal.AngularWebpackPlugin;
// (undocumented)
export type AngularPluginOptions = ivyInternal.AngularWebpackPluginOptions;
// (undocumented)
export type AngularWebpackPlugin = ivyInternal.AngularWebpackPlugin;
}
// (No @packageDocumentation comment for this package)
```

5
package.json
View File

@ -20,7 +20,7 @@
],
"scripts": {
"admin": "node ./bin/devkit-admin",
"bazel:test": "bazel test //packages/... //goldens/public-api/... ",
"bazel:test": "bazel test //packages/...",
"build": "node ./bin/devkit-admin build",
"build-tsc": "tsc -p tsconfig.json",
"debug:test": "node --inspect-brk ./bin/devkit-admin test",
@ -32,6 +32,8 @@
"//webdriver-update-README": "ChromeDriver version must match Puppeteer Chromium version, see https://github.com/GoogleChrome/puppeteer/releases http://chromedriver.chromium.org/downloads",
"webdriver-update": "webdriver-manager update --standalone false --gecko false --versions.chrome 91.0.4472.19",
"ngcc": "ngcc --properties es2015 browser module main --first-only --create-ivy-entry-points",
"public-api:check": "node goldens/public-api/manage.js test",
"public-api:update": "node goldens/public-api/manage.js accept",
"ts-circular-deps:check": "ng-dev ts-circular-deps check --config ./packages/circular-deps-test.conf.js",
"ts-circular-deps:approve": "ng-dev ts-circular-deps approve --config ./packages/circular-deps-test.conf.js"
},
@ -222,7 +224,6 @@
"terser-webpack-plugin": "5.1.4",
"text-table": "0.2.0",
"tree-kill": "1.2.2",
"ts-api-guardian": "0.6.0",
"ts-node": "^10.0.0",
"tslib": "2.3.0",
"tslint": "^6.1.3",

11
packages/angular_devkit/architect/BUILD.bazel
View File

@ -10,6 +10,7 @@ load("//tools:ts_json_schema.bzl", "ts_json_schema")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
licenses(["notice"]) # MIT
@ -103,4 +104,14 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "architect_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/architect",
npm_package = "angular_cli/packages/angular_devkit/architect/npm_package",
)
# @external_end

12
packages/angular_devkit/build_angular/BUILD.bazel
View File

@ -10,6 +10,7 @@ load("//tools:ts_json_schema.bzl", "ts_json_schema")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
licenses(["notice"]) # MIT
@ -111,7 +112,6 @@ ts_library(
"@npm//@angular/service-worker",
"@npm//@babel/core",
"@npm//@babel/helper-annotate-as-pure",
"@npm//@babel/plugin-transform-async-to-generator",
"@npm//@babel/plugin-transform-runtime",
"@npm//@babel/preset-env",
"@npm//@babel/runtime",
@ -240,6 +240,16 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "build_angular_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/build_angular",
npm_package = "angular_cli/packages/angular_devkit/build_angular/npm_package",
)
# @external_end
# Large build_angular specs

11
packages/angular_devkit/build_optimizer/BUILD.bazel
View File

@ -9,6 +9,7 @@ load("//tools:defaults.bzl", "ts_library")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
licenses(["notice"]) # MIT
@ -80,4 +81,14 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "build_optimizer_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/build_optimizer",
npm_package = "angular_cli/packages/angular_devkit/build_optimizer/npm_package",
)
# @external_end

10
packages/angular_devkit/build_optimizer/src/_golden-api.ts
View File

@ -1,10 +0,0 @@
/**
* @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
*/
export * from './index';
export { default } from './build-optimizer/webpack-loader';

11
packages/angular_devkit/build_webpack/BUILD.bazel
View File

@ -10,6 +10,7 @@ load("//tools:ts_json_schema.bzl", "ts_json_schema")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
licenses(["notice"]) # MIT
@ -118,4 +119,14 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "build_webpack_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/build_webpack",
npm_package = "angular_cli/packages/angular_devkit/build_webpack/npm_package",
)
# @external_end

12
packages/angular_devkit/core/BUILD.bazel
View File

@ -4,6 +4,7 @@ load("//tools:defaults.bzl", "ts_library")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
# Copyright Google Inc. All Rights Reserved.
@ -93,4 +94,15 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "core_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/core",
npm_package = "angular_cli/packages/angular_devkit/core/npm_package",
types = ["@npm//@types/node"],
)
# @external_end

17
packages/angular_devkit/core/node/_golden-api.ts
View File

@ -1,17 +0,0 @@
/**
* @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
*/
// Start experimental namespace
// Start jobs namespace
export * from './experimental/jobs/job-registry';
// End jobs namespace
// End experimental namespace
export * from './fs';
export * from './cli-logger';
export * from './host';

52
packages/angular_devkit/core/src/_golden-api.ts
View File

@ -1,52 +0,0 @@
/**
* @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
*/
export * from './exception/exception';
// Start json namespace
export * from './json/interface';
export * from './json/parser';
export * from './json/schema/interface';
export * from './json/schema/pointer';
export * from './json/schema/registry';
export * from './json/schema/visitor';
export * from './json/schema/utility';
export * from './json/schema/transforms';
// End json namespace
// Start logging namespace
export * from './logger/indent';
export * from './logger/level';
export * from './logger/logger';
export * from './logger/null-logger';
export * from './logger/transform-logger';
// End logging namespace
// Start utils namespace
export * from './utils/literals';
export * from './utils/strings';
export * from './utils/array';
export * from './utils/object';
export * from './utils/template';
export * from './utils/partially-ordered-set';
export * from './utils/priority-queue';
export * from './utils/lang';
// End utils namespace
// Start virtualFs namespace
export * from './virtual-fs/path';
export * from './virtual-fs/host/index';
// End virtualFs namespace
// Start workspace namespace
export * from './workspace/index';
// End workspace namespace
// Start analytics namespace
export * from './analytics/index';
// End analytics namespace

12
packages/angular_devkit/schematics/BUILD.bazel
View File

@ -4,6 +4,7 @@ load("//tools:defaults.bzl", "ts_library")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
# Copyright Google Inc. All Rights Reserved.
@ -84,4 +85,15 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "schematics_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/angular_devkit/schematics",
npm_package = "angular_cli/packages/angular_devkit/schematics/npm_package",
types = ["@npm//@types/node"],
)
# @external_end

13
packages/angular_devkit/schematics/src/_golden-api.ts
View File

@ -1,13 +0,0 @@
/**
* @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
*/
export * from './index';
export * from './formats/index';
export * from './workflow/index';

11
packages/ngtools/webpack/BUILD.bazel
View File

@ -9,6 +9,7 @@ load("//tools:defaults.bzl", "ts_library")
# @external_begin
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm")
load("@npm//@angular/dev-infra-private/bazel/api-golden:index.bzl", "api_golden_test_npm_package")
# @external_end
licenses(["notice"]) # MIT
@ -86,4 +87,14 @@ pkg_tar(
strip_prefix = "./npm_package",
tags = ["manual"],
)
api_golden_test_npm_package(
name = "ngtools_webpack_api",
data = [
":npm_package",
"//goldens:public-api",
],
golden_dir = "angular_cli/goldens/public-api/ngtools/webpack",
npm_package = "angular_cli/packages/ngtools/webpack/npm_package",
)
# @external_end

20
yarn.lock
View File

@ -94,8 +94,7 @@
"@angular/dev-infra-private@https://github.com/angular/dev-infra-private-builds.git#d9656f649e17c99eb48bebee6c045db479a5cfb4":
version "0.0.0"
uid d9656f649e17c99eb48bebee6c045db479a5cfb4
resolved "https://github.com/angular/dev-infra-private-builds.git#d9656f649e17c99eb48bebee6c045db479a5cfb4"
resolved "https://github.com/angular/dev-infra-private-builds.git#82da7f78a15b1a00a60402a51a2c5424e9699d53"
dependencies:
"@angular/benchpress" "0.2.1"
"@bazel/buildifier" "^4.0.1"
@ -3365,7 +3364,7 @@ chalk@^1.1.1, chalk@^1.1.3:
strip-ansi "^3.0.0"
supports-color "^2.0.0"
chalk@^2.0.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1, chalk@^2.4.2:
chalk@^2.0.0, chalk@^2.3.0, chalk@^2.4.1, chalk@^2.4.2:
version "2.4.2"
resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
@ -4375,11 +4374,6 @@ di@^0.0.1:
resolved "https://registry.yarnpkg.com/di/-/di-0.0.1.tgz#806649326ceaa7caa3306d75d985ea2748ba913c"
integrity sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=
diff@^3.5.0:
version "3.5.0"
resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12"
integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==
diff@^4.0.1:
version "4.0.2"
resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
@ -10057,7 +10051,6 @@ sass@1.35.2, sass@^1.32.8:
"sauce-connect-proxy@https://saucelabs.com/downloads/sc-4.6.4-linux.tar.gz":
version "0.0.0"
uid "992e2cb0d91e54b27a4f5bbd2049f3b774718115"
resolved "https://saucelabs.com/downloads/sc-4.6.4-linux.tar.gz#992e2cb0d91e54b27a4f5bbd2049f3b774718115"
saucelabs@^1.5.0:
@ -11199,15 +11192,6 @@ trim-off-newlines@^1.0.0:
resolved "https://registry.yarnpkg.com/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3"
integrity sha1-n5up2e+odkw4dpi8v+sshI8RrbM=
ts-api-guardian@0.6.0:
version "0.6.0"
resolved "https://registry.yarnpkg.com/ts-api-guardian/-/ts-api-guardian-0.6.0.tgz#9f44cf9bad1db5de358ccca7b4e6fb1d2c7fe462"
integrity sha512-DVA+UgPI1TVRI7GNDG1XBxwGs+cKqJq1os00txr52TUxBPwsUWWT7f83VHWvPQvh7G2wj93U/dTUBeDq3FIDTg==
dependencies:
chalk "^2.3.1"
diff "^3.5.0"
minimist "^1.2.0"
ts-node@^10.0.0:
version "10.1.0"
resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.1.0.tgz#e656d8ad3b61106938a867f69c39a8ba6efc966e"