codify-plugin-lib 1.0.176 → 1.0.178

package/dist/entities/resource.js

@@ -1,303 +0,0 @@
-import { Ajv } from 'ajv';
-import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
-import { setsEqual, splitUserConfig } from '../utils/utils.js';
-import { Plan } from './plan.js';
-import { ResourceOptionsParser } from './resource-options.js';
-export class Resource {
-    typeId;
-    statefulParameters;
-    transformParameters;
-    resourceParameters;
-    statefulParameterOrder;
-    transformParameterOrder;
-    dependencies;
-    parameterOptions;
-    options;
-    defaultValues;
-    ajv;
-    schemaValidator;
-    constructor(options) {
-        this.typeId = options.type;
-        this.dependencies = options.dependencies ?? [];
-        this.options = options;
-        if (this.options.schema) {
-            this.ajv = new Ajv({
-                allErrors: true,
-                strict: true,
-                strictRequired: false,
-            });
-            this.schemaValidator = this.ajv.compile(this.options.schema);
-        }
-        const parser = new ResourceOptionsParser(options);
-        this.statefulParameters = parser.statefulParameters;
-        this.transformParameters = parser.transformParameters;
-        this.resourceParameters = parser.resourceParameters;
-        this.parameterOptions = parser.changeSetParameterOptions;
-        this.defaultValues = parser.defaultValues;
-        this.statefulParameterOrder = parser.statefulParameterOrder;
-        this.transformParameterOrder = parser.transformParameterOrder;
-    }
-    async onInitialize() { }
-    async validate(parameters, resourceMetaData) {
-        if (this.schemaValidator) {
-            const isValid = this.schemaValidator(parameters);
-            if (!isValid) {
-                return {
-                    isValid: false,
-                    resourceName: resourceMetaData.name,
-                    resourceType: resourceMetaData.type,
-                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
-                };
-            }
-        }
-        let isValid = true;
-        let customValidationErrorMessage;
-        try {
-            await this.customValidation(parameters);
-        }
-        catch (error) {
-            isValid = false;
-            customValidationErrorMessage = error.message;
-        }
-        if (!isValid) {
-            return {
-                customValidationErrorMessage,
-                isValid: false,
-                resourceName: resourceMetaData.name,
-                resourceType: resourceMetaData.type,
-                schemaValidationErrors: this.schemaValidator?.errors ?? [],
-            };
-        }
-        return {
-            isValid: true,
-            resourceName: resourceMetaData.name,
-            resourceType: resourceMetaData.type,
-            schemaValidationErrors: [],
-        };
-    }
-    async plan(desiredConfig, currentConfig = null, statefulMode = false) {
-        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
-        const planOptions = {
-            parameterOptions: this.parameterOptions,
-            statefulMode,
-        };
-        this.addDefaultValues(desiredConfig);
-        await this.applyTransformParameters(desiredConfig);
-        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
-        const { desiredParameters, nonStatefulParameters, resourceMetadata, statefulParameters, } = parsedConfig;
-        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
-        if (currentParameters === null || currentParameters === undefined) {
-            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
-        }
-        const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
-        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
-    }
-    async apply(plan) {
-        if (plan.getResourceType() !== this.typeId) {
-            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
-        }
-        switch (plan.changeSet.operation) {
-            case ResourceOperation.CREATE: {
-                return this._applyCreate(plan);
-            }
-            case ResourceOperation.MODIFY: {
-                return this._applyModify(plan);
-            }
-            case ResourceOperation.RECREATE: {
-                await this._applyDestroy(plan);
-                return this._applyCreate(plan);
-            }
-            case ResourceOperation.DESTROY: {
-                return this._applyDestroy(plan);
-            }
-        }
-    }
-    async _applyCreate(plan) {
-        await this.applyCreate(plan);
-        const statefulParameterChanges = plan.changeSet.parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name))
-            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
-        for (const parameterChange of statefulParameterChanges) {
-            const statefulParameter = this.statefulParameters.get(parameterChange.name);
-            await statefulParameter.applyAdd(parameterChange.newValue, plan);
-        }
-    }
-    async _applyModify(plan) {
-        const parameterChanges = plan
-            .changeSet
-            .parameterChanges
-            .filter((c) => c.operation !== ParameterOperation.NOOP);
-        const statelessParameterChanges = parameterChanges
-            .filter((pc) => !this.statefulParameters.has(pc.name));
-        for (const pc of statelessParameterChanges) {
-            await this.applyModify(pc, plan);
-        }
-        const statefulParameterChanges = parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name))
-            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
-        for (const parameterChange of statefulParameterChanges) {
-            const statefulParameter = this.statefulParameters.get(parameterChange.name);
-            switch (parameterChange.operation) {
-                case ParameterOperation.ADD: {
-                    await statefulParameter.applyAdd(parameterChange.newValue, plan);
-                    break;
-                }
-                case ParameterOperation.MODIFY: {
-                    await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
-                    break;
-                }
-                case ParameterOperation.REMOVE: {
-                    await statefulParameter.applyRemove(parameterChange.previousValue, plan);
-                    break;
-                }
-            }
-        }
-    }
-    async _applyDestroy(plan) {
-        if (this.options.callStatefulParameterRemoveOnDestroy) {
-            const statefulParameterChanges = plan.changeSet.parameterChanges
-                .filter((pc) => this.statefulParameters.has(pc.name))
-                .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
-            for (const parameterChange of statefulParameterChanges) {
-                const statefulParameter = this.statefulParameters.get(parameterChange.name);
-                await statefulParameter.applyRemove(parameterChange.previousValue, plan);
-            }
-        }
-        await this.applyDestroy(plan);
-    }
-    validateRefreshResults(refresh, desired) {
-        if (!refresh) {
-            return;
-        }
-        const desiredKeys = new Set(Object.keys(refresh));
-        const refreshKeys = new Set(Object.keys(refresh));
-        if (!setsEqual(desiredKeys, refreshKeys)) {
-            throw new Error(`Resource ${this.typeId}
-refresh() must return back exactly the keys that were provided
-Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
-Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
-        }
-    }
-    async applyTransformParameters(desired) {
-        if (!desired) {
-            return;
-        }
-        const transformParameters = [...this.transformParameters.entries()]
-            .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
-        for (const [key, transformParameter] of transformParameters) {
-            if (desired[key] === undefined) {
-                continue;
-            }
-            const transformedValue = await transformParameter.transform(desired[key]);
-            if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
-                throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
-            }
-            delete desired[key];
-            for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
-                desired[tvKey] = tvValue;
-            }
-        }
-    }
-    addDefaultValues(desired) {
-        if (!desired) {
-            return;
-        }
-        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
-            if (defaultValue !== undefined && desired[key] === undefined) {
-                desired[key] = defaultValue;
-            }
-        }
-    }
-    async refreshNonStatefulParameters(resourceParameters) {
-        const currentParameters = await this.refresh(resourceParameters);
-        this.validateRefreshResults(currentParameters, resourceParameters);
-        return currentParameters;
-    }
-    async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
-        const currentParameters = {};
-        const sortedEntries = Object.entries(statefulParametersConfig)
-            .sort(([key1], [key2]) => this.statefulParameterOrder.get(key1) - this.statefulParameterOrder.get(key2));
-        for (const [key, desiredValue] of sortedEntries) {
-            const statefulParameter = this.statefulParameters.get(key);
-            if (!statefulParameter) {
-                throw new Error(`Stateful parameter ${key} was not found`);
-            }
-            let currentValue = await statefulParameter.refresh(desiredValue ?? null);
-            if (Array.isArray(currentValue)
-                && Array.isArray(desiredValue)
-                && !isStatefulMode
-                && !statefulParameter.options.disableStatelessModeArrayFiltering) {
-                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
-                    const parameterOptions = statefulParameter.options;
-                    if (parameterOptions && parameterOptions.isElementEqual) {
-                        return parameterOptions.isElementEqual(d, c);
-                    }
-                    return d === c;
-                }));
-            }
-            currentParameters[key] = currentValue;
-        }
-        return currentParameters;
-    }
-    validatePlanInputs(desired, current, statefulMode) {
-        if (!desired && !current) {
-            throw new Error('Desired config and current config cannot both be missing');
-        }
-        if (!statefulMode && !desired) {
-            throw new Error('Desired config must be provided in non-stateful mode');
-        }
-    }
-    async customValidation(parameters) { }
-    ;
-    async applyModify(pc, plan) { }
-    ;
-}
-class ConfigParser {
-    desiredConfig;
-    currentConfig;
-    statefulParametersMap;
-    transformParametersMap;
-    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
-        this.desiredConfig = desiredConfig;
-        this.currentConfig = currentConfig;
-        this.statefulParametersMap = statefulParameters;
-        this.transformParametersMap = transformParameters;
-    }
-    get resourceMetadata() {
-        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
-        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
-        if (!desiredMetadata && !currentMetadata) {
-            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
-        }
-        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
-            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
-            throw new Error(`The metadata for the current config does not match the desired config. 
-Desired metadata:
-${JSON.stringify(desiredMetadata, null, 2)}
-
-Current metadata:
-${JSON.stringify(currentMetadata, null, 2)}`);
-        }
-        return desiredMetadata ?? currentMetadata;
-    }
-    get desiredParameters() {
-        if (!this.desiredConfig) {
-            return null;
-        }
-        const { parameters } = splitUserConfig(this.desiredConfig);
-        return parameters;
-    }
-    get parameters() {
-        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
-        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
-        return { ...desiredParameters, ...currentParameters };
-    }
-    get nonStatefulParameters() {
-        const { parameters } = this;
-        return Object.fromEntries(Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))));
-    }
-    get statefulParameters() {
-        const { parameters } = this;
-        return Object.fromEntries(Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)));
-    }
-}

package/dist/entities/stateful-parameter.d.ts

@@ -1,29 +0,0 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-export interface StatefulParameterOptions<V> {
-    isEqual?: (desired: any, current: any) => boolean;
-    disableStatelessModeArrayFiltering?: boolean;
-    default?: V;
-}
-export interface ArrayStatefulParameterOptions<V> extends StatefulParameterOptions<V> {
-    isEqual?: (desired: any[], current: any[]) => boolean;
-    isElementEqual?: (desired: any, current: any) => boolean;
-}
-export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
-    readonly options: StatefulParameterOptions<V>;
-    constructor(options?: StatefulParameterOptions<V>);
-    abstract refresh(desired: V | null): Promise<V | null>;
-    abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
-    abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
-    abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
-}
-export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
-    options: ArrayStatefulParameterOptions<V>;
-    constructor(options?: ArrayStatefulParameterOptions<V>);
-    applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
-    applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
-    applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
-    abstract refresh(desired: V[] | null): Promise<V[] | null>;
-    abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
-    abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
-}

package/dist/entities/stateful-parameter.js

@@ -1,46 +0,0 @@
-export class StatefulParameter {
-    options;
-    constructor(options = {}) {
-        this.options = options;
-    }
-}
-export class ArrayStatefulParameter extends StatefulParameter {
-    options;
-    constructor(options = {}) {
-        super(options);
-        this.options = options;
-    }
-    async applyAdd(valuesToAdd, plan) {
-        for (const value of valuesToAdd) {
-            await this.applyAddItem(value, plan);
-        }
-    }
-    async applyModify(newValues, previousValues, allowDeletes, plan) {
-        const options = this.options;
-        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
-            if (options.isElementEqual) {
-                return options.isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
-            if (options.isElementEqual) {
-                return options.isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        for (const value of valuesToAdd) {
-            await this.applyAddItem(value, plan);
-        }
-        if (allowDeletes) {
-            for (const value of valuesToRemove) {
-                await this.applyRemoveItem(value, plan);
-            }
-        }
-    }
-    async applyRemove(valuesToRemove, plan) {
-        for (const value of valuesToRemove) {
-            await this.applyRemoveItem(value, plan);
-        }
-    }
-}

package/dist/entities/transform-parameter.d.ts

@@ -1,4 +0,0 @@
-import { StringIndexedObject } from 'codify-schemas';
-export declare abstract class TransformParameter<T extends StringIndexedObject> {
-    abstract transform(value: any): Promise<Partial<T>>;
-}

package/dist/entities/transform-parameter.js

@@ -1,2 +0,0 @@
-export class TransformParameter {
-}

package/dist/pty/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/pty/vitest.config.js

@@ -1,11 +0,0 @@
-import { defaultExclude, defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        pool: 'forks',
-        fileParallelism: false,
-        exclude: [
-            ...defaultExclude,
-            './src/utils/test-utils.test.ts',
-        ]
-    },
-});

package/dist/resource/stateful-parameter.d.ts

@@ -1,165 +0,0 @@
-import { StringIndexedObject } from 'codify-schemas';
-import { Plan } from '../plan/plan.js';
-import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
-/**
- * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
- * is still tied to the overall lifecycle of a resource.
- *
- * **Examples include:**
- * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
- * overall lifecycle of homebrew
- * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
- * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
- */
-export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
-    /**
-     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
-     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
-     * information on available settings.
-     *
-     * @return The parameter settings
-     */
-    getSettings(): ParameterSetting;
-    /**
-     * Refresh the status of the stateful parameter on the system. This method works similarly to {@link Resource.refresh}.
-     * Return the value of the stateful parameter or null if not found.
-     *
-     * @param desired The desired value of the user.
-     * @param config The desired config
-     *
-     * @return The value of the stateful parameter currently on the system or null if not found
-     */
-    abstract refresh(desired: V | null, config: Partial<T>): Promise<V | null>;
-    /**
-     * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
-     * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the
-     * resource is successfully created. The add method is called when a ParameterChange is ADD in a plan. The add
-     * method is only called when the stateful parameter does not currently exist.
-     *
-     * **Example (Homebrew formula):**
-     * 1. Add is called with a value of:
-     * ```
-     * ['jq', 'jenv']
-     * ```
-     * 2. Add handles the request by calling `brew install --formulae jq jenv`
-     *
-     * @param valueToAdd The desired value of the stateful parameter.
-     * @param plan The overall plan that contains the ADD
-     */
-    abstract add(valueToAdd: V, plan: Plan<T>): Promise<void>;
-    /**
-     * Modify the state of a stateful parameter on the system. This method is similar to {@link Resource.modify} except that its only
-     * applicable to the stateful parameter.
-     *
-     * **Example (Git email parameter):**
-     * 1. Add is called with a value of:
-     * ```
-     * newValue: 'email+new@gmail.com', previousValue: 'email+old@gmail.com'
-     * ```
-     * 2. Modify handles the request by calling `git config --global user.email email+new@gmail.com`
-     *
-     * @param newValue The desired value of the stateful parameter
-     * @param previousValue The current value of the stateful parameter
-     * @param plan The overall plan
-     */
-    abstract modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void>;
-    /**
-     * Create the stateful parameter on the system. This method is similar {@link Resource.destroy} except that its only
-     * applicable to the stateful parameter. The remove method is only called when the stateful parameter already currently exist.
-     * This method corresponds to REMOVE parameter operations in a plan.
-     * For resource `DESTORY`, this method is only called if the {@link ResourceSettings.removeStatefulParametersBeforeDestroy}
-     * is set to true. This method will be called before the resource is destroyed.
-     *
-     * **Example (Homebrew formula):**
-     * 1. Remove is called with a value of:
-     * ```
-     * ['jq', 'jenv']
-     * ```
-     * 2. Remove handles the request by calling `brew uninstall --formulae jq jenv`
-     *
-     * @param valueToRemove The value to remove from the stateful parameter.
-     * @param plan The overall plan that contains the REMOVE
-     */
-    abstract remove(valueToRemove: V, plan: Plan<T>): Promise<void>;
-}
-/**
- * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
- * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
- * is still tied to the overall lifecycle of a resource.
- *
- * **Examples:**
- * - Homebrew formulas are arrays
- * - Pyenv python versions are arrays
- */
-export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
-    /**
-     * Parameter level settings. Type must be 'array'.
-     */
-    getSettings(): ArrayParameterSetting;
-    /**
-     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
-     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
-     *
-     * @param valuesToAdd The array of values to add
-     * @param plan The overall plan
-     *
-     */
-    add(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
-    /**
-     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
-     * on the modifications. See {@link StatefulParameter.modify} for more info.
-     *
-     * @param newValues The new array value
-     * @param previousValues The previous array value
-     * @param plan The overall plan
-     */
-    modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void>;
-    /**
-     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
-     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
-     *
-     * @param valuesToAdd The array of values to add
-     * @param plan The overall plan
-     *
-     */
-    remove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
-    /**
-     * See {@link StatefulParameter.refresh} for more info.
-     *
-     * @param desired The desired value to refresh
-     * @return The current value on the system or null if not found.
-     */
-    abstract refresh(desired: V[] | null, config: Partial<T>): Promise<V[] | null>;
-    /**
-     * Helper method that gets called when individual elements of the array need to be added. See {@link StatefulParameter.add}
-     * for more information.
-     *
-     * Example (Homebrew formula):
-     * 1. The stateful parameter receives an input of:
-     * ```
-     * ['jq', 'jenv', 'docker']
-     * ```
-     * 2. Internally the stateful parameter will iterate the array and call `addItem` for each element
-     * 3. Override addItem and install each formula using `brew install --formula jq`
-     *
-     * @param item The item to add (install)
-     * @param plan The overall plan
-     */
-    abstract addItem(item: V, plan: Plan<T>): Promise<void>;
-    /**
-     * Helper method that gets called when individual elements of the array need to be removed. See {@link StatefulParameter.remove}
-     * for more information.
-     *
-     * Example (Homebrew formula):
-     * 1. The stateful parameter receives an input of:
-     * ```
-     * ['jq', 'jenv', 'docker']
-     * ```
-     * 2. Internally the stateful parameter will iterate the array and call `removeItem` for each element
-     * 3. Override removeItem and uninstall each formula using `brew uninstall --formula jq`
-     *
-     * @param item The item to remove (uninstall)
-     * @param plan The overall plan
-     */
-    abstract removeItem(item: V, plan: Plan<T>): Promise<void>;
-}

package/dist/resource/stateful-parameter.js

@@ -1,94 +0,0 @@
-/**
- * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
- * is still tied to the overall lifecycle of a resource.
- *
- * **Examples include:**
- * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
- * overall lifecycle of homebrew
- * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
- * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
- */
-export class StatefulParameter {
-    /**
-     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
-     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
-     * information on available settings.
-     *
-     * @return The parameter settings
-     */
-    getSettings() {
-        return {};
-    }
-}
-/**
- * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
- * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
- * is still tied to the overall lifecycle of a resource.
- *
- * **Examples:**
- * - Homebrew formulas are arrays
- * - Pyenv python versions are arrays
- */
-export class ArrayStatefulParameter extends StatefulParameter {
-    /**
-     * Parameter level settings. Type must be 'array'.
-     */
-    getSettings() {
-        return { type: 'array' };
-    }
-    /**
-     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
-     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
-     *
-     * @param valuesToAdd The array of values to add
-     * @param plan The overall plan
-     *
-     */
-    async add(valuesToAdd, plan) {
-        for (const value of valuesToAdd) {
-            await this.addItem(value, plan);
-        }
-    }
-    /**
-     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
-     * on the modifications. See {@link StatefulParameter.modify} for more info.
-     *
-     * @param newValues The new array value
-     * @param previousValues The previous array value
-     * @param plan The overall plan
-     */
-    async modify(newValues, previousValues, plan) {
-        // TODO: I don't think this works with duplicate elements. Solve at another time
-        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
-            if (this.getSettings()?.isElementEqual) {
-                return this.getSettings().isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
-            if (this.getSettings().isElementEqual) {
-                return this.getSettings().isElementEqual(n, p);
-            }
-            return n === p;
-        }));
-        for (const value of valuesToAdd) {
-            await this.addItem(value, plan);
-        }
-        for (const value of valuesToRemove) {
-            await this.removeItem(value, plan);
-        }
-    }
-    /**
-     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
-     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
-     *
-     * @param valuesToAdd The array of values to add
-     * @param plan The overall plan
-     *
-     */
-    async remove(valuesToRemove, plan) {
-        for (const value of valuesToRemove) {
-            await this.removeItem(value, plan);
-        }
-    }
-}

package/dist/utils/spawn-2.d.ts

@@ -1,5 +0,0 @@
-import { Shell } from 'zx';
-export declare class ShellContext implements Shell {
-    zx: Shell;
-    static create(): ShellContext;
-}

package/dist/utils/spawn-2.js

@@ -1,7 +0,0 @@
-import { $ } from 'zx';
-export class ShellContext {
-    zx = $({ shell: true });
-    static create() {
-        return new ShellContext();
-    }
-}