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

package/src/utils/rxjs-for-await.d.ts

@@ -0,0 +1,109 @@
+import type { Observable } from 'rxjs';
+export declare class Deferred<T> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+}
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function eachValueFrom<T>(source: Observable<T>): AsyncIterableIterator<T>;
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function bufferedValuesFrom<T>(source: Observable<T>): AsyncGenerator<T[]>;
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function latestValueFrom<T>(source: Observable<T>): AsyncGenerator<T>;
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function nextValueFrom<T>(source: Observable<T>): AsyncGenerator<T, void, void>;

package/src/utils/rxjs-for-await.js

@@ -0,0 +1,363 @@
+"use strict";
+// Remove this if https://github.com/benlesh/rxjs-for-await/issues/15 is addressed
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextValueFrom = exports.latestValueFrom = exports.bufferedValuesFrom = exports.eachValueFrom = exports.Deferred = void 0;
+class Deferred {
+    constructor() {
+        this.resolve = null;
+        this.reject = null;
+        this.promise = new Promise((a, b) => {
+            this.resolve = a;
+            this.reject = b;
+        });
+    }
+}
+exports.Deferred = Deferred;
+const RESOLVED = Promise.resolve();
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* eachValueFrom(source) {
+    const deferreds = [];
+    const values = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferreds.length > 0) {
+                deferreds.shift().resolve({ value, done: false });
+            }
+            else {
+                values.push(value);
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            while (deferreds.length > 0) {
+                deferreds.shift().reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            while (deferreds.length > 0) {
+                deferreds.shift().resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (values.length > 0) {
+                yield values.shift();
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                const d = new Deferred();
+                deferreds.push(d);
+                const result = await d.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.eachValueFrom = eachValueFrom;
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* bufferedValuesFrom(source) {
+    let deferred = null;
+    const buffer = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    const bufferCopy = buffer.slice();
+                    buffer.length = 0;
+                    return { value: bufferCopy, done: false };
+                }));
+                deferred = null;
+            }
+            buffer.push(value);
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+                deferred = null;
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+                deferred = null;
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (buffer.length > 0) {
+                const bufferCopy = buffer.slice();
+                buffer.length = 0;
+                yield bufferCopy;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.bufferedValuesFrom = bufferedValuesFrom;
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* latestValueFrom(source) {
+    let deferred = undefined;
+    let latestValue;
+    let hasLatestValue = false;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            hasLatestValue = true;
+            latestValue = value;
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    hasLatestValue = false;
+                    return { value: latestValue, done: false };
+                }));
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                hasLatestValue = false;
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (hasLatestValue) {
+                await RESOLVED;
+                const value = latestValue;
+                hasLatestValue = false;
+                yield value;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.latestValueFrom = latestValueFrom;
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* nextValueFrom(source) {
+    let deferred = undefined;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve({ value, done: false });
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.nextValueFrom = nextValueFrom;

package/src/utils/semver.d.ts

@@ -0,0 +1 @@
+export declare function checkAndCleanWithSemver(pkgName: string, version: string): string;

package/src/utils/semver.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndCleanWithSemver = void 0;
+const semver_1 = require("semver");
+function checkAndCleanWithSemver(pkgName, version) {
+    let newVersion = version;
+    if ((0, semver_1.valid)(newVersion)) {
+        return newVersion;
+    }
+    if (version.startsWith('~') || version.startsWith('^')) {
+        newVersion = version.substring(1);
+    }
+    if (!(0, semver_1.valid)(newVersion)) {
+        throw new Error(`The package.json lists a version of ${pkgName} that Nx is unable to validate - (${version})`);
+    }
+    return newVersion;
+}
+exports.checkAndCleanWithSemver = checkAndCleanWithSemver;

package/src/utils/string-change.d.ts

@@ -0,0 +1,62 @@
+export declare enum ChangeType {
+    Delete = "Delete",
+    Insert = "Insert"
+}
+export interface StringDeletion {
+    type: ChangeType.Delete;
+    /**
+     * Place in the original text to start deleting characters
+     */
+    start: number;
+    /**
+     * Number of characters to delete
+     */
+    length: number;
+}
+export interface StringInsertion {
+    type: ChangeType.Insert;
+    /**
+     * Text to insert into the original text
+     */
+    text: string;
+    /**
+     * Place in the original text to insert new text
+     */
+    index: number;
+}
+/**
+ * A change to be made to a string
+ */
+export type StringChange = StringInsertion | StringDeletion;
+/**
+ * Applies a list of changes to a string's original value.
+ *
+ * This is useful when working with ASTs.
+ *
+ * For Example, to rename a property in a method's options:
+ *
+ * ```typescript
+ * const code = `bootstrap({
+ *   target: document.querySelector('#app')
+ * })`;
+ *
+ * const indexOfPropertyName = 13; // Usually determined by analyzing an AST.
+ * const updatedCode = applyChangesToString(code, [
+ *   {
+ *     type: ChangeType.Insert,
+ *     index: indexOfPropertyName,
+ *     text: 'element'
+ *   },
+ *   {
+ *     type: ChangeType.Delete,
+ *     start: indexOfPropertyName,
+ *     length: 6
+ *   },
+ * ]);
+ *
+ * bootstrap({
+ *   element: document.querySelector('#app')
+ * });
+ * ```
+ */
+export declare function applyChangesToString(text: string, changes: StringChange[]): string;

package/src/utils/string-change.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyChangesToString = exports.ChangeType = void 0;
+var ChangeType;
+(function (ChangeType) {
+    ChangeType["Delete"] = "Delete";
+    ChangeType["Insert"] = "Insert";
+})(ChangeType || (exports.ChangeType = ChangeType = {}));
+/**
+ * Applies a list of changes to a string's original value.
+ *
+ * This is useful when working with ASTs.
+ *
+ * For Example, to rename a property in a method's options:
+ *
+ * ```typescript
+ * const code = `bootstrap({
+ *   target: document.querySelector('#app')
+ * })`;
+ *
+ * const indexOfPropertyName = 13; // Usually determined by analyzing an AST.
+ * const updatedCode = applyChangesToString(code, [
+ *   {
+ *     type: ChangeType.Insert,
+ *     index: indexOfPropertyName,
+ *     text: 'element'
+ *   },
+ *   {
+ *     type: ChangeType.Delete,
+ *     start: indexOfPropertyName,
+ *     length: 6
+ *   },
+ * ]);
+ *
+ * bootstrap({
+ *   element: document.querySelector('#app')
+ * });
+ * ```
+ */
+function applyChangesToString(text, changes) {
+    assertChangesValid(changes);
+    const sortedChanges = changes.sort((a, b) => {
+        const diff = getChangeIndex(a) - getChangeIndex(b);
+        if (diff === 0) {
+            if (a.type === b.type) {
+                return 0;
+            }
+            else {
+                // When at the same place, Insert before Delete
+                return isStringInsertion(a) ? -1 : 1;
+            }
+        }
+        return diff;
+    });
+    let offset = 0;
+    for (const change of sortedChanges) {
+        const index = getChangeIndex(change) + offset;
+        if (isStringInsertion(change)) {
+            text = text.slice(0, index) + change.text + text.slice(index);
+            offset += change.text.length;
+        }
+        else {
+            text = text.slice(0, index) + text.slice(index + change.length);
+            offset -= change.length;
+        }
+    }
+    return text;
+}
+exports.applyChangesToString = applyChangesToString;
+function assertChangesValid(changes) {
+    for (const change of changes) {
+        if (isStringInsertion(change)) {
+            if (!Number.isInteger(change.index)) {
+                throw new TypeError(`${change.index} must be an integer.`);
+            }
+            if (change.index < 0) {
+                throw new Error(`${change.index} must be a positive integer.`);
+            }
+            if (typeof change.text !== 'string') {
+                throw new Error(`${change.text} must be a string.`);
+            }
+        }
+        else {
+            if (!Number.isInteger(change.start)) {
+                throw new TypeError(`${change.start} must be an integer.`);
+            }
+            if (change.start < 0) {
+                throw new Error(`${change.start} must be a positive integer.`);
+            }
+            if (!Number.isInteger(change.length)) {
+                throw new TypeError(`${change.length} must be an integer.`);
+            }
+            if (change.length < 0) {
+                throw new Error(`${change.length} must be a positive integer.`);
+            }
+        }
+    }
+}
+function getChangeIndex(change) {
+    if (isStringInsertion(change)) {
+        return change.index;
+    }
+    else {
+        return change.start;
+    }
+}
+function isStringInsertion(change) {
+    return change.type === ChangeType.Insert;
+}