diff options
Diffstat (limited to 'sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src')
25 files changed, 1497 insertions, 0 deletions
diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.d.ts new file mode 100644 index 00000000..dd238a9d --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.d.ts @@ -0,0 +1,267 @@ +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + */ +import { analytics, experimental, json, logging } from '@angular-devkit/core'; +import { Observable, SubscribableOrPromise } from 'rxjs'; +import { Schema as RealBuilderInput, Target as RealTarget } from './input-schema'; +import { Schema as RealBuilderOutput } from './output-schema'; +import { State as BuilderProgressState, Schema as RealBuilderProgress } from './progress-schema'; +export declare type Target = json.JsonObject & RealTarget; +export { BuilderProgressState }; +export declare type BuilderRegistry = experimental.jobs.Registry<json.JsonObject, BuilderInput, BuilderOutput>; +/** + * An API typed BuilderProgress. The interface generated from the schema is too permissive, + * so this API is the one we show in our API. Please note that not all fields are in there; this + * is in addition to fields in the schema. + */ +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; +}; +/** + * Declaration of those types as JsonObject compatible. JsonObject is not compatible with + * optional members, so those wouldn't be directly assignable to our internal Json typings. + * Forcing the type to be both a JsonObject and the type from the Schema tells Typescript they + * are compatible (which they are). + * These types should be used everywhere. + */ +export declare type BuilderInput = json.JsonObject & RealBuilderInput; +export declare type BuilderOutput = json.JsonObject & RealBuilderOutput; +export declare type BuilderProgress = json.JsonObject & RealBuilderProgress & TypedBuilderProgress; +/** + * A progress report is what the tooling will receive. It contains the builder info and the target. + * Although these are serializable, they are only exposed through the tooling interface, not the + * builder interface. The watch dog sends BuilderProgress and the Builder has a set of functions + * to manage the state. + */ +export declare type BuilderProgressReport = BuilderProgress & { + target?: Target; + builder: BuilderInfo; +}; +/** + * A Run, which is what is returned by scheduleBuilder or scheduleTarget functions. This should + * be reconstructed across memory boundaries (it's not serializable but all internal information + * are). + */ +export interface BuilderRun { + /** + * Unique amongst runs. This is the same ID as the context generated for the run. It can be + * used to identify multiple unique runs. There is no guarantee that a run is a single output; + * a builder can rebuild on its own and will generate multiple outputs. + */ + id: number; + /** + * The builder information. + */ + info: BuilderInfo; + /** + * The next output from a builder. This is recommended when scheduling a builder and only being + * interested in the result of that single run, not of a watch-mode builder. + */ + result: Promise<BuilderOutput>; + /** + * The output(s) from the builder. A builder can have multiple outputs. + * This always replay the last output when subscribed. + */ + output: Observable<BuilderOutput>; + /** + * The progress report. A progress also contains an ID, which can be different than this run's + * ID (if the builder calls scheduleBuilder or scheduleTarget). + * This will always replay the last progress on new subscriptions. + */ + progress: Observable<BuilderProgressReport>; + /** + * Stop the builder from running. Returns a promise that resolves when the builder is stopped. + * Some builders might not handle stopping properly and should have a timeout here. + */ + stop(): Promise<void>; +} +/** + * Additional optional scheduling options. + */ +export interface ScheduleOptions { + /** + * Logger to pass to the builder. Note that messages will stop being forwarded, and if you want + * to log a builder scheduled from your builder you should forward log events yourself. + */ + logger?: logging.Logger; + /** + * Target to pass to the builder. + */ + target?: Target; +} +/** + * The context received as a second argument in your builder. + */ +export interface BuilderContext { + /** + * Unique amongst contexts. Contexts instances are not guaranteed to be the same (but it could + * be the same context), and all the fields in a context could be the same, yet the builder's + * context could be different. This is the same ID as the corresponding run. + */ + id: number; + /** + * The builder info that called your function. Since the builder info is from the builder.json + * (or the host), it could contain information that is different than expected. + */ + builder: BuilderInfo; + /** + * A logger that appends messages to a log. This could be a separate interface or completely + * ignored. `console.log` could also be completely ignored. + */ + logger: logging.LoggerApi; + /** + * The absolute workspace root of this run. This is a system path and will not be normalized; + * ie. on Windows it will starts with `C:\\` (or whatever drive). + */ + workspaceRoot: string; + /** + * The current directory the user is in. This could be outside the workspace root. This is a + * system path and will not be normalized; ie. on Windows it will starts with `C:\\` (or + * whatever drive). + */ + currentDirectory: string; + /** + * The target that was used to run this builder. + * Target is optional if a builder was ran using `scheduleBuilder()`. + */ + target?: Target; + /** + * Schedule a target in the same workspace. This can be the same target that is being executed + * right now, but targets of the same name are serialized. + * Running the same target and waiting for it to end will result in a deadlocking scenario. + * Targets are considered the same if the project, the target AND the configuration are the same. + * @param target The target to schedule. + * @param overrides A set of options to override the workspace set of options. + * @param scheduleOptions Additional optional scheduling options. + * @return A promise of a run. It will resolve when all the members of the run are available. + */ + scheduleTarget(target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>; + /** + * Schedule a builder by its name. This can be the same builder that is being executed. + * @param builderName The name of the builder, ie. its `packageName:builderName` tuple. + * @param options All options to use for the builder (by default empty object). There is no + * additional options added, e.g. from the workspace. + * @param scheduleOptions Additional optional scheduling options. + * @return A promise of a run. It will resolve when all the members of the run are available. + */ + scheduleBuilder(builderName: string, options?: json.JsonObject, scheduleOptions?: ScheduleOptions): Promise<BuilderRun>; + /** + * Resolve and return options for a specified target. If the target isn't defined in the + * workspace this will reject the promise. This object will be read directly from the workspace + * but not validated against the builder of the target. + * @param target The target to resolve the options of. + * @return A non-validated object resolved from the workspace. + */ + getTargetOptions(target: Target): Promise<json.JsonObject>; + getProjectMetadata(projectName: string): Promise<json.JsonObject>; + getProjectMetadata(target: Target): Promise<json.JsonObject>; + /** + * Resolves and return a builder name. The exact format of the name is up to the host, + * so it should not be parsed to gather information (it's free form). This string can be + * used to validate options or schedule a builder directly. + * @param target The target to resolve the builder name. + */ + getBuilderNameForTarget(target: Target): Promise<string>; + /** + * Validates the options against a builder schema. This uses the same methods as the + * scheduleTarget and scheduleBrowser methods to validate and apply defaults to the options. + * It can be generically typed, if you know which interface it is supposed to validate against. + * @param options A generic option object to validate. + * @param builderName The name of a builder to use. This can be gotten for a target by using the + * getBuilderForTarget() method on the context. + */ + validateOptions<T extends json.JsonObject = json.JsonObject>(options: json.JsonObject, builderName: string): Promise<T>; + /** + * Set the builder to running. This should be used if an external event triggered a re-run, + * e.g. a file watched was changed. + */ + reportRunning(): void; + /** + * Update the status string shown on the interface. + * @param status The status to set it to. An empty string can be used to remove the status. + */ + reportStatus(status: string): void; + /** + * Update the progress for this builder run. + * @param current The current progress. This will be between 0 and total. + * @param total A new total to set. By default at the start of a run this is 1. If omitted it + * will use the same value as the last total. + * @param status Update the status string. If omitted the status string is not modified. + */ + reportProgress(current: number, total?: number, status?: string): void; + /** + * API to report analytics. This might be undefined if the feature is unsupported. This might + * not be undefined, but the backend could also not report anything. + */ + readonly analytics: analytics.Analytics; + /** + * Add teardown logic to this Context, so that when it's being stopped it will execute teardown. + */ + addTeardown(teardown: () => Promise<void> | void): void; +} +/** + * An accepted return value from a builder. Can be either an Observable, a Promise or a vector. + */ +export declare type BuilderOutputLike = AsyncIterable<BuilderOutput> | SubscribableOrPromise<BuilderOutput> | BuilderOutput; +export declare function isBuilderOutput(obj: any): obj is BuilderOutput; +export declare function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Observable<T>; +/** + * A builder handler function. The function signature passed to `createBuilder()`. + */ +export interface BuilderHandlerFn<A> { + /** + * Builders are defined by users to perform any kind of task, like building, testing or linting, + * and should use this interface. + * @param input The options (a JsonObject), validated by the schema and received by the + * builder. This can include resolved options from the CLI or the workspace. + * @param context A context that can be used to interact with the Architect framework. + * @return One or many builder output. + */ + (input: A, context: BuilderContext): BuilderOutputLike; +} +/** + * A Builder general information. This is generated by the host and is expanded by the host, but + * the public API contains those fields. + */ +export declare type BuilderInfo = json.JsonObject & { + builderName: string; + description: string; + optionSchema: json.schema.JsonSchema; +}; +/** + * Returns a string of "project:target[:configuration]" for the target object. + */ +export declare function targetStringFromTarget({ project, target, configuration }: Target): string; +/** + * Return a Target tuple from a string. + */ +export declare function targetFromTargetString(str: string): Target; +/** + * Schedule a target, and forget about its run. This will return an observable of outputs, that + * as a a teardown will stop the target from running. This means that the Run object this returns + * should not be shared. + * + * The reason this is not part of the Context interface is to keep the Context as normal form as + * possible. This is really an utility that people would implement in their project. + * + * @param context The context of your current execution. + * @param target The target to schedule. + * @param overrides Overrides that are used in the target. + * @param scheduleOptions Additional scheduling options. + */ +export declare function scheduleTargetAndForget(context: BuilderContext, target: Target, overrides?: json.JsonObject, scheduleOptions?: ScheduleOptions): Observable<BuilderOutput>; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.js new file mode 100644 index 00000000..b780d744 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/api.js @@ -0,0 +1,98 @@ +"use strict"; +/** + * @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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.scheduleTargetAndForget = exports.targetFromTargetString = exports.targetStringFromTarget = exports.fromAsyncIterable = exports.isBuilderOutput = exports.BuilderProgressState = void 0; +const rxjs_1 = require("rxjs"); +const operators_1 = require("rxjs/operators"); +const progress_schema_1 = require("./progress-schema"); +Object.defineProperty(exports, "BuilderProgressState", { enumerable: true, get: function () { return progress_schema_1.State; } }); +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function isBuilderOutput(obj) { + if (!obj || typeof obj.then === 'function' || typeof obj.subscribe === 'function') { + return false; + } + if (typeof obj[Symbol.asyncIterator] === 'function') { + return false; + } + return typeof obj.success === 'boolean'; +} +exports.isBuilderOutput = isBuilderOutput; +function fromAsyncIterable(iterable) { + return new rxjs_1.Observable((subscriber) => { + handleAsyncIterator(subscriber, iterable[Symbol.asyncIterator]()).then(() => subscriber.complete(), (error) => subscriber.error(error)); + }); +} +exports.fromAsyncIterable = fromAsyncIterable; +async function handleAsyncIterator(subscriber, iterator) { + var _a; + const teardown = new Promise((resolve) => subscriber.add(() => resolve())); + try { + while (!subscriber.closed) { + const result = await Promise.race([teardown, iterator.next()]); + if (!result || result.done) { + break; + } + subscriber.next(result.value); + } + } + finally { + await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator)); + } +} +/** + * Returns a string of "project:target[:configuration]" for the target object. + */ +function targetStringFromTarget({ project, target, configuration }) { + return `${project}:${target}${configuration !== undefined ? ':' + configuration : ''}`; +} +exports.targetStringFromTarget = targetStringFromTarget; +/** + * Return a Target tuple from a string. + */ +function targetFromTargetString(str) { + const tuple = str.split(/:/, 3); + if (tuple.length < 2) { + throw new Error('Invalid target string: ' + JSON.stringify(str)); + } + return { + project: tuple[0], + target: tuple[1], + ...(tuple[2] !== undefined && { configuration: tuple[2] }), + }; +} +exports.targetFromTargetString = targetFromTargetString; +/** + * Schedule a target, and forget about its run. This will return an observable of outputs, that + * as a a teardown will stop the target from running. This means that the Run object this returns + * should not be shared. + * + * The reason this is not part of the Context interface is to keep the Context as normal form as + * possible. This is really an utility that people would implement in their project. + * + * @param context The context of your current execution. + * @param target The target to schedule. + * @param overrides Overrides that are used in the target. + * @param scheduleOptions Additional scheduling options. + */ +function scheduleTargetAndForget(context, target, overrides, scheduleOptions) { + let resolve = null; + const promise = new Promise((r) => (resolve = r)); + context.addTeardown(() => promise); + return (0, rxjs_1.from)(context.scheduleTarget(target, overrides, scheduleOptions)).pipe((0, operators_1.switchMap)((run) => new rxjs_1.Observable((observer) => { + const subscription = run.output.subscribe(observer); + return () => { + subscription.unsubscribe(); + // We can properly ignore the floating promise as it's a "reverse" promise; the teardown + // is waiting for the resolve. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + run.stop().then(resolve); + }; + }))); +} +exports.scheduleTargetAndForget = scheduleTargetAndForget; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.d.ts new file mode 100644 index 00000000..eeec89df --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.d.ts @@ -0,0 +1,25 @@ +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + */ +import { analytics, experimental, json, logging } from '@angular-devkit/core'; +import { Observable } from 'rxjs'; +import { BuilderRun, Target } from './api'; +import { ArchitectHost } from './internal'; +export interface ScheduleOptions { + logger?: logging.Logger; + analytics?: analytics.Analytics; +} +export declare class Architect { + private _host; + private readonly _scheduler; + private readonly _jobCache; + private readonly _infoCache; + 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>; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.js new file mode 100644 index 00000000..93bb5db9 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/architect.js @@ -0,0 +1,283 @@ +"use strict"; +/** + * @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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Architect = void 0; +const core_1 = require("@angular-devkit/core"); +const rxjs_1 = require("rxjs"); +const operators_1 = require("rxjs/operators"); +const api_1 = require("./api"); +const schedule_by_name_1 = require("./schedule-by-name"); +const inputSchema = require('./input-schema.json'); +const outputSchema = require('./output-schema.json'); +function _createJobHandlerFromBuilderInfo(info, target, host, registry, baseOptions) { + const jobDescription = { + name: target ? `{${(0, api_1.targetStringFromTarget)(target)}}` : info.builderName, + argument: { type: 'object' }, + input: inputSchema, + output: outputSchema, + info, + }; + function handler(argument, context) { + // Add input validation to the inbound bus. + const inboundBusWithInputValidation = context.inboundBus.pipe((0, operators_1.concatMap)((message) => { + if (message.kind === core_1.experimental.jobs.JobInboundMessageKind.Input) { + const v = message.value; + const options = { + ...baseOptions, + ...v.options, + }; + // Validate v against the options schema. + return registry.compile(info.optionSchema).pipe((0, operators_1.concatMap)((validation) => validation(options)), (0, operators_1.map)((validationResult) => { + const { data, success, errors } = validationResult; + if (success) { + return { ...v, options: data }; + } + throw new core_1.json.schema.SchemaValidationException(errors); + }), (0, operators_1.map)((value) => ({ ...message, value }))); + } + else { + return (0, rxjs_1.of)(message); + } + }), + // Using a share replay because the job might be synchronously sending input, but + // asynchronously listening to it. + (0, operators_1.shareReplay)(1)); + // Make an inboundBus that completes instead of erroring out. + // We'll merge the errors into the output instead. + const inboundBus = (0, rxjs_1.onErrorResumeNext)(inboundBusWithInputValidation); + const output = (0, rxjs_1.from)(host.loadBuilder(info)).pipe((0, operators_1.concatMap)((builder) => { + if (builder === null) { + throw new Error(`Cannot load builder for builderInfo ${JSON.stringify(info, null, 2)}`); + } + return builder.handler(argument, { ...context, inboundBus }).pipe((0, operators_1.map)((output) => { + if (output.kind === core_1.experimental.jobs.JobOutboundMessageKind.Output) { + // Add target to it. + return { + ...output, + value: { + ...output.value, + ...(target ? { target } : 0), + }, + }; + } + else { + return output; + } + })); + }), + // Share subscriptions to the output, otherwise the the handler will be re-run. + (0, operators_1.shareReplay)()); + // Separate the errors from the inbound bus into their own observable that completes when the + // builder output does. + const inboundBusErrors = inboundBusWithInputValidation.pipe((0, operators_1.ignoreElements)(), (0, operators_1.takeUntil)((0, rxjs_1.onErrorResumeNext)(output.pipe((0, operators_1.last)())))); + // Return the builder output plus any input errors. + return (0, rxjs_1.merge)(inboundBusErrors, output); + } + return (0, rxjs_1.of)(Object.assign(handler, { jobDescription })); +} +/** + * A JobRegistry that resolves builder targets from the host. + */ +class ArchitectBuilderJobRegistry { + constructor(_host, _registry, _jobCache, _infoCache) { + this._host = _host; + this._registry = _registry; + this._jobCache = _jobCache; + this._infoCache = _infoCache; + } + _resolveBuilder(name) { + const cache = this._infoCache; + if (cache) { + const maybeCache = cache.get(name); + if (maybeCache !== undefined) { + return maybeCache; + } + const info = (0, rxjs_1.from)(this._host.resolveBuilder(name)).pipe((0, operators_1.shareReplay)(1)); + cache.set(name, info); + return info; + } + return (0, rxjs_1.from)(this._host.resolveBuilder(name)); + } + _createBuilder(info, target, options) { + const cache = this._jobCache; + if (target) { + const maybeHit = cache && cache.get((0, api_1.targetStringFromTarget)(target)); + if (maybeHit) { + return maybeHit; + } + } + else { + const maybeHit = cache && cache.get(info.builderName); + if (maybeHit) { + return maybeHit; + } + } + const result = _createJobHandlerFromBuilderInfo(info, target, this._host, this._registry, options || {}); + if (cache) { + if (target) { + cache.set((0, api_1.targetStringFromTarget)(target), result.pipe((0, operators_1.shareReplay)(1))); + } + else { + cache.set(info.builderName, result.pipe((0, operators_1.shareReplay)(1))); + } + } + return result; + } + get(name) { + const m = name.match(/^([^:]+):([^:]+)$/i); + if (!m) { + return (0, rxjs_1.of)(null); + } + return (0, rxjs_1.from)(this._resolveBuilder(name)).pipe((0, operators_1.concatMap)((builderInfo) => (builderInfo ? this._createBuilder(builderInfo) : (0, rxjs_1.of)(null))), (0, operators_1.first)(null, null)); + } +} +/** + * A JobRegistry that resolves targets from the host. + */ +class ArchitectTargetJobRegistry extends ArchitectBuilderJobRegistry { + get(name) { + const m = name.match(/^{([^:]+):([^:]+)(?::([^:]*))?}$/i); + if (!m) { + return (0, rxjs_1.of)(null); + } + const target = { + project: m[1], + target: m[2], + configuration: m[3], + }; + return (0, rxjs_1.from)(Promise.all([ + this._host.getBuilderNameForTarget(target), + this._host.getOptionsForTarget(target), + ])).pipe((0, operators_1.concatMap)(([builderStr, options]) => { + if (builderStr === null || options === null) { + return (0, rxjs_1.of)(null); + } + return this._resolveBuilder(builderStr).pipe((0, operators_1.concatMap)((builderInfo) => { + if (builderInfo === null) { + return (0, rxjs_1.of)(null); + } + return this._createBuilder(builderInfo, target, options); + })); + }), (0, operators_1.first)(null, null)); + } +} +function _getTargetOptionsFactory(host) { + return core_1.experimental.jobs.createJobHandler((target) => { + return host.getOptionsForTarget(target).then((options) => { + if (options === null) { + throw new Error(`Invalid target: ${JSON.stringify(target)}.`); + } + return options; + }); + }, { + name: '..getTargetOptions', + output: { type: 'object' }, + argument: inputSchema.properties.target, + }); +} +function _getProjectMetadataFactory(host) { + return core_1.experimental.jobs.createJobHandler((target) => { + return host.getProjectMetadata(target).then((options) => { + if (options === null) { + throw new Error(`Invalid target: ${JSON.stringify(target)}.`); + } + return options; + }); + }, { + name: '..getProjectMetadata', + output: { type: 'object' }, + argument: { + oneOf: [{ type: 'string' }, inputSchema.properties.target], + }, + }); +} +function _getBuilderNameForTargetFactory(host) { + return core_1.experimental.jobs.createJobHandler(async (target) => { + const builderName = await host.getBuilderNameForTarget(target); + if (!builderName) { + throw new Error(`No builder were found for target ${(0, api_1.targetStringFromTarget)(target)}.`); + } + return builderName; + }, { + name: '..getBuilderNameForTarget', + output: { type: 'string' }, + argument: inputSchema.properties.target, + }); +} +function _validateOptionsFactory(host, registry) { + return core_1.experimental.jobs.createJobHandler(async ([builderName, options]) => { + // Get option schema from the host. + const builderInfo = await host.resolveBuilder(builderName); + if (!builderInfo) { + throw new Error(`No builder info were found for builder ${JSON.stringify(builderName)}.`); + } + return registry + .compile(builderInfo.optionSchema) + .pipe((0, operators_1.concatMap)((validation) => validation(options)), (0, operators_1.switchMap)(({ data, success, errors }) => { + if (success) { + return (0, rxjs_1.of)(data); + } + throw new core_1.json.schema.SchemaValidationException(errors); + })) + .toPromise(); + }, { + name: '..validateOptions', + output: { type: 'object' }, + argument: { + type: 'array', + items: [{ type: 'string' }, { type: 'object' }], + }, + }); +} +class Architect { + constructor(_host, registry = new core_1.json.schema.CoreSchemaRegistry(), additionalJobRegistry) { + this._host = _host; + this._jobCache = new Map(); + this._infoCache = new Map(); + const privateArchitectJobRegistry = new core_1.experimental.jobs.SimpleJobRegistry(); + // Create private jobs. + privateArchitectJobRegistry.register(_getTargetOptionsFactory(_host)); + privateArchitectJobRegistry.register(_getBuilderNameForTargetFactory(_host)); + privateArchitectJobRegistry.register(_validateOptionsFactory(_host, registry)); + privateArchitectJobRegistry.register(_getProjectMetadataFactory(_host)); + const jobRegistry = new core_1.experimental.jobs.FallbackRegistry([ + new ArchitectTargetJobRegistry(_host, registry, this._jobCache, this._infoCache), + new ArchitectBuilderJobRegistry(_host, registry, this._jobCache, this._infoCache), + privateArchitectJobRegistry, + ...(additionalJobRegistry ? [additionalJobRegistry] : []), + ]); + this._scheduler = new core_1.experimental.jobs.SimpleScheduler(jobRegistry, registry); + } + has(name) { + return this._scheduler.has(name); + } + scheduleBuilder(name, options, scheduleOptions = {}) { + // The below will match 'project:target:configuration' + if (!/^[^:]+:[^:]+(:[^:]+)?$/.test(name)) { + throw new Error('Invalid builder name: ' + JSON.stringify(name)); + } + return (0, schedule_by_name_1.scheduleByName)(name, options, { + scheduler: this._scheduler, + logger: scheduleOptions.logger || new core_1.logging.NullLogger(), + currentDirectory: this._host.getCurrentDirectory(), + workspaceRoot: this._host.getWorkspaceRoot(), + analytics: scheduleOptions.analytics, + }); + } + scheduleTarget(target, overrides = {}, scheduleOptions = {}) { + return (0, schedule_by_name_1.scheduleByTarget)(target, overrides, { + scheduler: this._scheduler, + logger: scheduleOptions.logger || new core_1.logging.NullLogger(), + currentDirectory: this._host.getCurrentDirectory(), + workspaceRoot: this._host.getWorkspaceRoot(), + analytics: scheduleOptions.analytics, + }); + } +} +exports.Architect = Architect; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.d.ts new file mode 100644 index 00000000..b9c5b7e4 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.d.ts @@ -0,0 +1,30 @@ +export interface Schema { + /** + * Link to schema. + */ + $schema?: string; + builders: { + [key: string]: Builder; + }; +} +/** + * Target options for Builders. + */ +export interface Builder { + /** + * The builder class module. + */ + class?: string; + /** + * Builder description. + */ + description: string; + /** + * The next generation builder module. + */ + implementation?: string; + /** + * Schema for builder option validation. + */ + schema: string; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.js new file mode 100644 index 00000000..4fb6d3d1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.js @@ -0,0 +1,4 @@ +"use strict"; +// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE +// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...). +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.json b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.json new file mode 100644 index 00000000..c71ef86e --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/builders-schema.json @@ -0,0 +1,62 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "BuildersSchema", + "title": "Builders schema for validating a list of builders.", + "type": "object", + "properties": { + "$schema": { + "type": "string", + "description": "Link to schema." + }, + "builders": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/builder" + } + } + }, + "required": ["builders"], + "definitions": { + "builder": { + "type": "object", + "description": "Target options for Builders.", + "allOf": [ + { + "properties": { + "schema": { + "type": "string", + "description": "Schema for builder option validation." + }, + "description": { + "type": "string", + "description": "Builder description." + } + }, + "required": ["schema", "description"] + }, + { + "anyOf": [ + { + "properties": { + "implementation": { + "type": "string", + "description": "The next generation builder module." + } + }, + "required": ["implementation"] + }, + { + "properties": { + "class": { + "type": "string", + "description": "The builder class module." + } + }, + "required": ["class"] + } + ] + } + ] + } + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.d.ts new file mode 100644 index 00000000..99cf3494 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.d.ts @@ -0,0 +1,11 @@ +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + */ +import { json } from '@angular-devkit/core'; +import { BuilderHandlerFn, BuilderOutput } from './api'; +import { Builder } from './internal'; +export declare function createBuilder<OptT = json.JsonObject, OutT extends BuilderOutput = BuilderOutput>(fn: BuilderHandlerFn<OptT>): Builder<OptT & json.JsonObject>; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.js new file mode 100644 index 00000000..bcff4656 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/create-builder.js @@ -0,0 +1,200 @@ +"use strict"; +/** + * @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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createBuilder = void 0; +const core_1 = require("@angular-devkit/core"); +const rxjs_1 = require("rxjs"); +const operators_1 = require("rxjs/operators"); +const api_1 = require("./api"); +const internal_1 = require("./internal"); +const schedule_by_name_1 = require("./schedule-by-name"); +// eslint-disable-next-line max-lines-per-function +function createBuilder(fn) { + const cjh = core_1.experimental.jobs.createJobHandler; + // eslint-disable-next-line max-lines-per-function + const handler = cjh((options, context) => { + const scheduler = context.scheduler; + const progressChannel = context.createChannel('progress'); + const logChannel = context.createChannel('log'); + const analyticsChannel = context.createChannel('analytics'); + let currentState = api_1.BuilderProgressState.Stopped; + const teardownLogics = []; + let tearingDown = false; + let current = 0; + let status = ''; + let total = 1; + function log(entry) { + logChannel.next(entry); + } + function progress(progress, context) { + currentState = progress.state; + if (progress.state === api_1.BuilderProgressState.Running) { + current = progress.current; + total = progress.total !== undefined ? progress.total : total; + if (progress.status === undefined) { + progress.status = status; + } + else { + status = progress.status; + } + } + progressChannel.next({ + ...progress, + ...(context.target && { target: context.target }), + ...(context.builder && { builder: context.builder }), + id: context.id, + }); + } + return new rxjs_1.Observable((observer) => { + const subscriptions = []; + const inputSubscription = context.inboundBus.subscribe((i) => { + switch (i.kind) { + case core_1.experimental.jobs.JobInboundMessageKind.Stop: + // Run teardown logic then complete. + tearingDown = true; + Promise.all(teardownLogics.map((fn) => fn() || Promise.resolve())).then(() => observer.complete(), (err) => observer.error(err)); + break; + case core_1.experimental.jobs.JobInboundMessageKind.Input: + if (!tearingDown) { + onInput(i.value); + } + break; + } + }); + function onInput(i) { + const builder = i.info; + const loggerName = i.target + ? (0, api_1.targetStringFromTarget)(i.target) + : builder.builderName; + const logger = new core_1.logging.Logger(loggerName); + subscriptions.push(logger.subscribe((entry) => log(entry))); + const context = { + builder, + workspaceRoot: i.workspaceRoot, + currentDirectory: i.currentDirectory, + target: i.target, + logger: logger, + id: i.id, + async scheduleTarget(target, overrides = {}, scheduleOptions = {}) { + const run = await (0, schedule_by_name_1.scheduleByTarget)(target, overrides, { + scheduler, + logger: scheduleOptions.logger || logger.createChild(''), + workspaceRoot: i.workspaceRoot, + currentDirectory: i.currentDirectory, + }); + // We don't want to subscribe errors and complete. + subscriptions.push(run.progress.subscribe((event) => progressChannel.next(event))); + return run; + }, + async scheduleBuilder(builderName, options = {}, scheduleOptions = {}) { + const run = await (0, schedule_by_name_1.scheduleByName)(builderName, options, { + scheduler, + target: scheduleOptions.target, + logger: scheduleOptions.logger || logger.createChild(''), + workspaceRoot: i.workspaceRoot, + currentDirectory: i.currentDirectory, + }); + // We don't want to subscribe errors and complete. + subscriptions.push(run.progress.subscribe((event) => progressChannel.next(event))); + return run; + }, + async getTargetOptions(target) { + return scheduler + .schedule('..getTargetOptions', target) + .output.toPromise(); + }, + async getProjectMetadata(target) { + return scheduler + .schedule('..getProjectMetadata', target) + .output.toPromise(); + }, + async getBuilderNameForTarget(target) { + return scheduler + .schedule('..getBuilderNameForTarget', target) + .output.toPromise(); + }, + async validateOptions(options, builderName) { + return scheduler + .schedule('..validateOptions', [ + builderName, + options, + ]) + .output.toPromise(); + }, + reportRunning() { + switch (currentState) { + case api_1.BuilderProgressState.Waiting: + case api_1.BuilderProgressState.Stopped: + progress({ state: api_1.BuilderProgressState.Running, current: 0, total }, context); + break; + } + }, + reportStatus(status) { + switch (currentState) { + case api_1.BuilderProgressState.Running: + progress({ state: currentState, status, current, total }, context); + break; + case api_1.BuilderProgressState.Waiting: + progress({ state: currentState, status }, context); + break; + } + }, + reportProgress(current, total, status) { + switch (currentState) { + case api_1.BuilderProgressState.Running: + progress({ state: currentState, current, total, status }, context); + } + }, + analytics: new core_1.analytics.ForwardingAnalytics((report) => analyticsChannel.next(report)), + addTeardown(teardown) { + teardownLogics.push(teardown); + }, + }; + context.reportRunning(); + let result; + try { + result = fn(i.options, context); + if ((0, api_1.isBuilderOutput)(result)) { + result = (0, rxjs_1.of)(result); + } + else if (!(0, rxjs_1.isObservable)(result) && isAsyncIterable(result)) { + result = (0, api_1.fromAsyncIterable)(result); + } + else { + result = (0, rxjs_1.from)(result); + } + } + catch (e) { + result = (0, rxjs_1.throwError)(e); + } + // Manage some state automatically. + progress({ state: api_1.BuilderProgressState.Running, current: 0, total: 1 }, context); + subscriptions.push(result + .pipe((0, operators_1.tap)(() => { + progress({ state: api_1.BuilderProgressState.Running, current: total }, context); + progress({ state: api_1.BuilderProgressState.Stopped }, context); + })) + .subscribe((message) => observer.next(message), (error) => observer.error(error), () => observer.complete())); + } + return () => { + subscriptions.forEach((x) => x.unsubscribe()); + inputSubscription.unsubscribe(); + }; + }); + }); + return { + handler, + [internal_1.BuilderSymbol]: true, + [internal_1.BuilderVersionSymbol]: require('../package.json').version, + }; +} +exports.createBuilder = createBuilder; +function isAsyncIterable(obj) { + return !!obj && typeof obj[Symbol.asyncIterator] === 'function'; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.d.ts new file mode 100644 index 00000000..dcfbb9d7 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.d.ts @@ -0,0 +1,10 @@ +/** + * @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 './api'; +export { Architect, ScheduleOptions } from './architect'; +export { createBuilder } from './create-builder'; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.js new file mode 100644 index 00000000..8dbdd392 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/index.js @@ -0,0 +1,25 @@ +"use strict"; +/** + * @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 + */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createBuilder = exports.Architect = void 0; +__exportStar(require("./api"), exports); +var architect_1 = require("./architect"); +Object.defineProperty(exports, "Architect", { enumerable: true, get: function () { return architect_1.Architect; } }); +var create_builder_1 = require("./create-builder"); +Object.defineProperty(exports, "createBuilder", { enumerable: true, get: function () { return create_builder_1.createBuilder; } }); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.d.ts new file mode 100644 index 00000000..614d5ed1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.d.ts @@ -0,0 +1,17 @@ +export interface Schema { + currentDirectory: string; + id: number; + info: { + [key: string]: any; + }; + options?: { + [key: string]: any; + }; + target?: Target; + workspaceRoot: string; +} +export interface Target { + configuration?: string; + project: string; + target: string; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.js new file mode 100644 index 00000000..4fb6d3d1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.js @@ -0,0 +1,4 @@ +"use strict"; +// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE +// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...). +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.json b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.json new file mode 100644 index 00000000..7559c096 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/input-schema.json @@ -0,0 +1,39 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "BuilderInputSchema", + "title": "Input schema for builders.", + "type": "object", + "properties": { + "workspaceRoot": { + "type": "string" + }, + "currentDirectory": { + "type": "string" + }, + "id": { + "type": "number" + }, + "target": { + "type": "object", + "properties": { + "project": { + "type": "string" + }, + "target": { + "type": "string" + }, + "configuration": { + "type": "string" + } + }, + "required": ["project", "target"] + }, + "info": { + "type": "object" + }, + "options": { + "type": "object" + } + }, + "required": ["currentDirectory", "id", "info", "workspaceRoot"] +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.d.ts new file mode 100644 index 00000000..c1364fa1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.d.ts @@ -0,0 +1,66 @@ +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + */ +import { experimental, json } from '@angular-devkit/core'; +import { BuilderInfo, BuilderInput, BuilderOutput, Target } from './api'; +/** + * BuilderSymbol used for knowing if a function was created using createBuilder(). This is a + * property set on the function that should be `true`. + * Using Symbol.for() as it's a global registry that's the same for all installations of + * Architect (if some libraries depends directly on architect instead of sharing the files). + */ +export declare const BuilderSymbol: unique symbol; +/** + * BuilderVersionSymbol used for knowing which version of the library createBuilder() came from. + * This is to make sure we don't try to use an incompatible builder. + * Using Symbol.for() as it's a global registry that's the same for all installations of + * Architect (if some libraries depends directly on architect instead of sharing the files). + */ +export declare const BuilderVersionSymbol: unique symbol; +/** + * A Specialization of the JobHandler type. This exposes BuilderDescription as the job description + * type. + */ +export declare type BuilderJobHandler<A extends json.JsonObject = json.JsonObject, I extends BuilderInput = BuilderInput, O extends BuilderOutput = BuilderOutput> = experimental.jobs.JobHandler<A, I, O> & { + jobDescription: BuilderDescription; +}; +/** + * A Builder description, which is used internally. Adds the builder info which is the + * metadata attached to a builder in Architect. + */ +export interface BuilderDescription extends experimental.jobs.JobDescription { + info: BuilderInfo; +} +/** + * A Builder instance. Use createBuilder() to create one of these. + */ +export interface Builder<OptionT extends json.JsonObject = json.JsonObject> { + handler: experimental.jobs.JobHandler<json.JsonObject, BuilderInput, BuilderOutput>; + [BuilderSymbol]: true; + [BuilderVersionSymbol]: string; +} +export interface ArchitectHost<BuilderInfoT extends BuilderInfo = BuilderInfo> { + /** + * Get the builder name for a target. + * @param target The target to inspect. + */ + getBuilderNameForTarget(target: Target): Promise<string | null>; + /** + * Resolve a builder. This needs to return a string which will be used in a dynamic `import()` + * clause. This should throw if no builder can be found. The dynamic import will throw if + * it is unsupported. + * @param builderName The name of the builder to be used. + * @returns All the info needed for the builder itself. + */ + resolveBuilder(builderName: string): Promise<BuilderInfoT | null>; + loadBuilder(info: BuilderInfoT): Promise<Builder | null>; + getCurrentDirectory(): Promise<string>; + getWorkspaceRoot(): Promise<string>; + getOptionsForTarget(target: Target): Promise<json.JsonObject | null>; + getProjectMetadata(projectName: string): Promise<json.JsonObject | null>; + getProjectMetadata(target: Target): Promise<json.JsonObject | null>; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.js new file mode 100644 index 00000000..f74de953 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/internal.js @@ -0,0 +1,26 @@ +"use strict"; +/** + * @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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BuilderVersionSymbol = exports.BuilderSymbol = void 0; +// Internal types that should not be exported directly. These are used by the host and architect +// itself. Host implementations should import the host.ts file. +/** + * BuilderSymbol used for knowing if a function was created using createBuilder(). This is a + * property set on the function that should be `true`. + * Using Symbol.for() as it's a global registry that's the same for all installations of + * Architect (if some libraries depends directly on architect instead of sharing the files). + */ +exports.BuilderSymbol = Symbol.for('@angular-devkit/architect:builder'); +/** + * BuilderVersionSymbol used for knowing which version of the library createBuilder() came from. + * This is to make sure we don't try to use an incompatible builder. + * Using Symbol.for() as it's a global registry that's the same for all installations of + * Architect (if some libraries depends directly on architect instead of sharing the files). + */ +exports.BuilderVersionSymbol = Symbol.for('@angular-devkit/architect:version'); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.d.ts new file mode 100644 index 00000000..f7431bf8 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.d.ts @@ -0,0 +1,13 @@ +export interface Schema { + error?: string; + info?: { + [key: string]: any; + }; + success: boolean; + target?: Target; +} +export interface Target { + configuration?: string; + project?: string; + target?: string; +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.js new file mode 100644 index 00000000..4fb6d3d1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.js @@ -0,0 +1,4 @@ +"use strict"; +// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE +// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...). +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.json b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.json new file mode 100644 index 00000000..5539068e --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/output-schema.json @@ -0,0 +1,33 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "BuilderOutputSchema", + "title": "Output schema for builders.", + "type": "object", + "properties": { + "success": { + "type": "boolean" + }, + "error": { + "type": "string" + }, + "target": { + "type": "object", + "properties": { + "project": { + "type": "string" + }, + "target": { + "type": "string" + }, + "configuration": { + "type": "string" + } + } + }, + "info": { + "type": "object" + } + }, + "additionalProperties": true, + "required": ["success"] +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.d.ts new file mode 100644 index 00000000..331c42be --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.d.ts @@ -0,0 +1,20 @@ +export interface Schema { + builder: { + [key: string]: any; + }; + current?: number; + error?: any; + id: number; + state: State; + status?: string; + target?: { + [key: string]: any; + }; + total?: number; +} +export declare enum State { + Error = "error", + Running = "running", + Stopped = "stopped", + Waiting = "waiting" +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.js new file mode 100644 index 00000000..e900879e --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.js @@ -0,0 +1,12 @@ +"use strict"; +// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE +// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...). +Object.defineProperty(exports, "__esModule", { value: true }); +exports.State = void 0; +var State; +(function (State) { + State["Error"] = "error"; + State["Running"] = "running"; + State["Stopped"] = "stopped"; + State["Waiting"] = "waiting"; +})(State = exports.State || (exports.State = {})); diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.json b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.json new file mode 100644 index 00000000..e782f4ad --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/progress-schema.json @@ -0,0 +1,83 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "BuilderProgressSchema", + "title": "Progress schema for builders.", + "type": "object", + "allOf": [ + { + "type": "object", + "oneOf": [ + { + "type": "object", + "properties": { + "state": { + "type": "string", + "enum": ["stopped"] + } + }, + "required": ["state"] + }, + { + "type": "object", + "properties": { + "state": { + "type": "string", + "enum": ["waiting"] + }, + "status": { + "type": "string" + } + }, + "required": ["state"] + }, + { + "type": "object", + "properties": { + "state": { + "type": "string", + "enum": ["running"] + }, + "current": { + "type": "number", + "minimum": 0 + }, + "total": { + "type": "number", + "minimum": 0 + }, + "status": { + "type": "string" + } + }, + "required": ["state"] + }, + { + "type": "object", + "properties": { + "state": { + "type": "string", + "enum": ["error"] + }, + "error": true + }, + "required": ["state"] + } + ] + }, + { + "type": "object", + "properties": { + "builder": { + "type": "object" + }, + "target": { + "type": "object" + }, + "id": { + "type": "number" + } + }, + "required": ["builder", "id"] + } + ] +} diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.d.ts b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.d.ts new file mode 100644 index 00000000..d62ba678 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.d.ts @@ -0,0 +1,24 @@ +/** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + */ +import { analytics, experimental, json, logging } from '@angular-devkit/core'; +import { BuilderRun, Target } from './api'; +export declare function scheduleByName(name: string, buildOptions: json.JsonObject, options: { + target?: Target; + scheduler: experimental.jobs.Scheduler; + logger: logging.LoggerApi; + workspaceRoot: string | Promise<string>; + currentDirectory: string | Promise<string>; + analytics?: analytics.Analytics; +}): Promise<BuilderRun>; +export declare function scheduleByTarget(target: Target, overrides: json.JsonObject, options: { + scheduler: experimental.jobs.Scheduler; + logger: logging.LoggerApi; + workspaceRoot: string | Promise<string>; + currentDirectory: string | Promise<string>; + analytics?: analytics.Analytics; +}): Promise<BuilderRun>; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.js new file mode 100644 index 00000000..b3dbac77 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/schedule-by-name.js @@ -0,0 +1,102 @@ +"use strict"; +/** + * @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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.scheduleByTarget = exports.scheduleByName = void 0; +const core_1 = require("@angular-devkit/core"); +const rxjs_1 = require("rxjs"); +const operators_1 = require("rxjs/operators"); +const api_1 = require("./api"); +const progressSchema = require('./progress-schema.json'); +let _uniqueId = 0; +async function scheduleByName(name, buildOptions, options) { + const childLoggerName = options.target ? `{${(0, api_1.targetStringFromTarget)(options.target)}}` : name; + const logger = options.logger.createChild(childLoggerName); + const job = options.scheduler.schedule(name, {}); + let stateSubscription; + const workspaceRoot = await options.workspaceRoot; + const currentDirectory = await options.currentDirectory; + const description = await job.description.toPromise(); + const info = description.info; + const id = ++_uniqueId; + const message = { + id, + currentDirectory, + workspaceRoot, + info: info, + options: buildOptions, + ...(options.target ? { target: options.target } : {}), + }; + // Wait for the job to be ready. + if (job.state !== core_1.experimental.jobs.JobState.Started) { + stateSubscription = job.outboundBus.subscribe((event) => { + if (event.kind === core_1.experimental.jobs.JobOutboundMessageKind.Start) { + job.input.next(message); + } + }, () => { }); + } + else { + job.input.next(message); + } + const logChannelSub = job.getChannel('log').subscribe((entry) => { + logger.next(entry); + }, () => { }); + const s = job.outboundBus.subscribe({ + error() { }, + complete() { + s.unsubscribe(); + logChannelSub.unsubscribe(); + if (stateSubscription) { + stateSubscription.unsubscribe(); + } + }, + }); + const output = job.output.pipe((0, operators_1.map)((output) => ({ + ...output, + ...(options.target ? { target: options.target } : 0), + info, + })), (0, operators_1.shareReplay)()); + // If there's an analytics object, take the job channel and report it to the analytics. + if (options.analytics) { + const reporter = new core_1.analytics.AnalyticsReporter(options.analytics); + job + .getChannel('analytics') + .subscribe((report) => reporter.report(report)); + } + // Start the builder. + output.pipe((0, operators_1.first)()).subscribe({ + error() { }, + }); + return { + id, + info, + // This is a getter so that it always returns the next output, and not the same one. + get result() { + return output.pipe((0, operators_1.first)()).toPromise(); + }, + output, + progress: job + .getChannel('progress', progressSchema) + .pipe((0, operators_1.shareReplay)(1)), + stop() { + job.stop(); + return job.outboundBus + .pipe((0, operators_1.ignoreElements)(), (0, operators_1.catchError)(() => rxjs_1.EMPTY)) + .toPromise(); + }, + }; +} +exports.scheduleByName = scheduleByName; +async function scheduleByTarget(target, overrides, options) { + return scheduleByName(`{${(0, api_1.targetStringFromTarget)(target)}}`, overrides, { + ...options, + target, + logger: options.logger, + }); +} +exports.scheduleByTarget = scheduleByTarget; diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/targets-schema.json b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/targets-schema.json new file mode 100644 index 00000000..912c20ff --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/architect/src/targets-schema.json @@ -0,0 +1,39 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "ArchitectTargets", + "title": "Targets schema for validating Architect targets configuration.", + "type": "object", + "description": "A map of available project targets.", + "additionalProperties": { + "$ref": "#/definitions/target" + }, + "required": [], + "definitions": { + "target": { + "type": "object", + "description": "Target options.", + "properties": { + "builder": { + "type": "string", + "description": "The builder used for this package." + }, + "options": { + "$ref": "#/definitions/options" + }, + "configurations": { + "type": "object", + "description": "A map of alternative target options.", + "additionalProperties": { + "$ref": "#/definitions/options" + } + } + }, + "additionalProperties": false, + "required": ["builder", "options"] + }, + "options": { + "type": "object", + "description": "Target options." + } + } +} |