codify-plugin-lib 1.0.80 → 1.0.82

package/dist/plan/change-set.d.ts

@@ -30,7 +30,7 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     static empty<T extends StringIndexedObject>(): ChangeSet<T>;
     static create<T extends StringIndexedObject>(desired: Partial<T>): ChangeSet<T>;
     static destroy<T extends StringIndexedObject>(current: Partial<T>): ChangeSet<T>;
-    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): Promise<ChangeSet<T>>;
+    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): ChangeSet<T>;
     /**
      * Calculates the differences between the desired and current parameters,
      * and returns a list of parameter changes that describe what needs to be added,

package/dist/plan/change-set.js

@@ -1,5 +1,4 @@
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { areArraysEqual } from '../utils/utils.js';
 // Change set will coerce undefined values to null because undefined is not valid JSON
 export class ChangeSet {
     operation;
@@ -45,8 +44,8 @@ export class ChangeSet {
         }));
         return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
     }
-    static async calculateModification(desired, current, parameterSettings = {}) {
-        const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+    static calculateModification(desired, current, parameterSettings = {}) {
+        const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
         const statefulParameterKeys = new Set(Object.entries(parameterSettings)
             .filter(([, v]) => v?.type === 'stateful')
             .map(([k]) => k));
@@ -77,7 +76,7 @@ export class ChangeSet {
      * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
      * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
      */
-    static async calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
+    static calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
         const parameterChangeSet = new Array();
         // Filter out null and undefined values or else the diff below will not work
         const desired = Object.fromEntries(Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined));
@@ -93,7 +92,7 @@ export class ChangeSet {
                 delete current[k];
                 continue;
             }
-            if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+            if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v ?? null,
@@ -138,19 +137,7 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
-    static async isSame(desired, current, setting) {
-        switch (setting?.type) {
-            case 'stateful': {
-                const statefulSetting = setting.definition.getSettings();
-                return ChangeSet.isSame(desired, current, statefulSetting);
-            }
-            case 'array': {
-                const arrayParameter = setting;
-                return areArraysEqual(arrayParameter, desired, current);
-            }
-            default: {
-                return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
-            }
-        }
+    static isSame(desired, current, setting) {
+        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
     }
 }

package/dist/plan/plan.d.ts

@@ -41,7 +41,7 @@ export declare class Plan<T extends StringIndexedObject> {
         coreParameters: ResourceConfig;
         settings: ParsedResourceSettings<T>;
         statefulMode: boolean;
-    }): Promise<Plan<T>>;
+    }): Plan<T>;
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.

package/dist/plan/plan.js

@@ -1,6 +1,5 @@
 import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { v4 as uuidV4 } from 'uuid';
-import { asyncFilter, asyncIncludes, asyncMap } from '../utils/utils.js';
 import { ChangeSet } from './change-set.js';
 /**
  * A plan represents a set of actions that after taken will turn the current resource into the desired one.
@@ -71,7 +70,7 @@ export class Plan {
     getResourceType() {
         return this.coreParameters.type;
     }
-    static async calculate(params) {
+    static calculate(params) {
         const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
         const currentParameters = Plan.matchCurrentParameters({
             desiredParameters,
@@ -80,7 +79,7 @@ export class Plan {
             settings,
             statefulMode
         });
-        const filteredCurrentParameters = await Plan.filterCurrentParams({
+        const filteredCurrentParameters = Plan.filterCurrentParams({
             desiredParameters,
             currentParameters,
             stateParameters,
@@ -100,7 +99,7 @@ export class Plan {
             return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters);
         }
         // NO-OP, MODIFY or RE-CREATE
-        const changeSet = await ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
+        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
         return new Plan(uuidV4(), changeSet, coreParameters);
     }
     /**
@@ -111,7 +110,7 @@ export class Plan {
      *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
-    static async filterCurrentParams(params) {
+    static filterCurrentParams(params) {
         const { desiredParameters: desired, currentParameters: current, stateParameters: state, settings, statefulMode } = params;
         if (!current) {
             return null;
@@ -126,8 +125,9 @@ export class Plan {
             return filteredCurrent;
         }
         // TODO: Add object handling here in addition to arrays in the future
-        const arrayStatefulParameters = Object.fromEntries(await asyncMap(Object.entries(filteredCurrent)
-            .filter(([k, v]) => isArrayStatefulParameter(k, v)), async ([k, v]) => [k, await filterArrayStatefulParameter(k, v)]));
+        const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
+            .filter(([k, v]) => isArrayStatefulParameter(k, v))
+            .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)]));
         return { ...filteredCurrent, ...arrayStatefulParameters };
         function filterCurrent() {
             if (!current) {
@@ -148,14 +148,26 @@ export class Plan {
                 && settings.parameterSettings[k].definition.getSettings().type === 'array'
                 && Array.isArray(v);
         }
-        async function filterArrayStatefulParameter(k, v) {
+        // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
+        function filterArrayStatefulParameter(k, v) {
             const desiredArray = desired[k];
             const matcher = settings.parameterSettings[k]
                 .definition
                 .getSettings()
-                .isElementEqual;
-            const eq = matcher ?? ((a, b) => a === b);
-            return asyncFilter(v, async (cv) => asyncIncludes(desiredArray, async (dv) => eq(dv, cv)));
+                .isElementEqual ?? ((a, b) => a === b);
+            const desiredCopy = [...desiredArray];
+            const currentCopy = [...v];
+            const result = [];
+            for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+                const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2));
+                if (idx === -1) {
+                    continue;
+                }
+                desiredCopy.splice(counter, 1);
+                const [element] = currentCopy.splice(idx, 1);
+                result.push(element);
+            }
+            return result;
         }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.

package/dist/resource/parsed-resource-settings.d.ts

@@ -21,6 +21,5 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     get statefulParameterOrder(): Map<keyof T, number>;
     private validateSettings;
     private validateParameterEqualsFn;
-    private resolveEqualsFn;
     private getFromCacheOrCreate;
 }

package/dist/resource/parsed-resource-settings.js

@@ -1,5 +1,4 @@
-import { areArraysEqual } from '../utils/utils.js';
-import { ParameterEqualsDefaults } from './resource-settings.js';
+import { resolveEqualsFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
@@ -35,7 +34,7 @@ export class ParsedResourceSettings {
             const settings = Object.entries(this.settings.parameterSettings ?? {})
                 .map(([k, v]) => [k, v])
                 .map(([k, v]) => {
-                v.isEqual = this.resolveEqualsFn(v, k);
+                v.isEqual = resolveEqualsFn(v, k);
                 return [k, v];
             });
             return Object.fromEntries(settings);
@@ -106,15 +105,6 @@ export class ParsedResourceSettings {
         }
         // The rest of the types have defaults set already
     }
-    resolveEqualsFn(parameter, key) {
-        if (parameter.type === 'array') {
-            return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter);
-        }
-        if (parameter.type === 'stateful') {
-            return this.resolveEqualsFn(parameter.definition.getSettings(), key);
-        }
-        return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
-    }
     getFromCacheOrCreate(key, create) {
         if (this.cache.has(key)) {
             return this.cache.get(key);

package/dist/resource/resource-settings.d.ts

@@ -97,7 +97,7 @@ export interface DefaultParameterSetting {
      *
      * @return Return true if equal
      */
-    isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+    isEqual?: (desired: any, current: any) => boolean;
     /**
      * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
      * Defaults to false (re-create).
@@ -123,7 +123,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
      *
      * @return Return true if desired is equivalent to current.
      */
-    isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
 }
 /**
  * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own
@@ -146,4 +146,4 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
      */
     order?: number;
 }
-export declare const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>>;
+export declare function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean;

package/dist/resource/resource-settings.js

@@ -1,9 +1,18 @@
 import path from 'node:path';
-import { untildify } from '../utils/utils.js';
-export const ParameterEqualsDefaults = {
+import { areArraysEqual, untildify } from '../utils/utils.js';
+const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
     'number': (a, b) => Number(a) === Number(b),
     'string': (a, b) => String(a) === String(b),
     'version': (desired, current) => String(current).includes(String(desired))
 };
+export function resolveEqualsFn(parameter, key) {
+    if (parameter.type === 'array') {
+        return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter);
+    }
+    if (parameter.type === 'stateful') {
+        return resolveEqualsFn(parameter.definition.getSettings(), key);
+    }
+    return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
+}

package/dist/utils/utils.d.ts

@@ -37,10 +37,5 @@ export declare function splitUserConfig<T extends StringIndexedObject>(config: R
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
 export declare function untildify(pathWithTilde: string): string;
-export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): Promise<boolean>;
-export declare function asyncFilter<T>(arr: T[], filter: (a: T) => Promise<boolean> | boolean): Promise<T[]>;
-export declare function asyncMap<T, R>(arr: T[], map: (a: T) => Promise<R> | R): Promise<R[]>;
-export declare function asyncFindIndex<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<number>;
-export declare function asyncFind<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<T | undefined>;
-export declare function asyncIncludes<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<boolean>;
+export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): boolean;
 export {};

package/dist/utils/utils.js

@@ -72,7 +72,7 @@ const homeDirectory = os.homedir();
 export function untildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
-export async function areArraysEqual(parameter, desired, current) {
+export function areArraysEqual(parameter, desired, current) {
     if (!Array.isArray(desired) || !Array.isArray(current)) {
         throw new Error(`A non-array value:
           
@@ -88,11 +88,10 @@ Was provided even though type array was specified.
     }
     const desiredCopy = [...desired];
     const currentCopy = [...current];
-    const eq = parameter.isElementEqual ?? ((a, b) => a === b);
     // Algorithm for to check equality between two un-ordered; un-hashable arrays using
     // an isElementEqual method. Time: O(n^2)
     for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-        const idx = await asyncFindIndex(currentCopy, (e2) => eq(desiredCopy[counter], e2));
+        const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2));
         if (idx === -1) {
             return false;
         }
@@ -101,43 +100,3 @@ Was provided even though type array was specified.
     }
     return currentCopy.length === 0;
 }
-export async function asyncFilter(arr, filter) {
-    const result = [];
-    for (const element of arr) {
-        if (await filter(element)) {
-            result.push(element);
-        }
-    }
-    return result;
-}
-export async function asyncMap(arr, map) {
-    const result = [];
-    for (const element of arr) {
-        result.push(await map(element));
-    }
-    return result;
-}
-export async function asyncFindIndex(arr, eq) {
-    for (const [counter, element] of arr.entries()) {
-        if (await eq(element)) {
-            return counter;
-        }
-    }
-    return -1;
-}
-export async function asyncFind(arr, eq) {
-    for (const element of arr) {
-        if (await eq(element)) {
-            return element;
-        }
-    }
-    return undefined;
-}
-export async function asyncIncludes(arr, eq) {
-    for (const element of arr) {
-        if (await eq(element)) {
-            return true;
-        }
-    }
-    return false;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "@oclif/prettier-config": "^0.2.1",
     "@oclif/test": "^3",
     "@types/npmcli__promise-spawn": "^6.0.3",
-    "@types/node": "^18",
+    "@types/node": "^20",
     "@types/semver": "^7.5.4",
     "@types/sinon": "^17.0.3",
     "@types/uuid": "^10.0.0",

package/src/plan/change-set.test.ts

@@ -1,9 +1,10 @@
 import { ChangeSet } from './change-set.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { describe, expect, it } from 'vitest';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 
-describe('Change set tests', async () => {
-  it ('Correctly diffs two resource configs (modify)', async () => {
+describe('Change set tests', () => {
+  it ('Correctly diffs two resource configs (modify)', () => {
     const after = {
       propA: 'before',
       propB: 'before'
@@ -14,14 +15,14 @@ describe('Change set tests', async () => {
       propB: 'after'
     }
 
-    const cs = await ChangeSet.calculateModification(after, before);
+    const cs = ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it ('Correctly diffs two resource configs (add)', async () => {
+  it ('Correctly diffs two resource configs (add)', () => {
     const after = {
       propA: 'before',
       propB: 'after'
@@ -31,7 +32,7 @@ describe('Change set tests', async () => {
       propA: 'after',
     }
 
-    const cs = await ChangeSet.calculateModification(after, before,);
+    const cs = ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
@@ -39,7 +40,7 @@ describe('Change set tests', async () => {
 
   })
 
-  it ('Correctly diffs two resource configs (remove)', async () => {
+  it ('Correctly diffs two resource configs (remove)', () => {
     const after = {
       propA: 'after',
     }
@@ -49,14 +50,14 @@ describe('Change set tests', async () => {
       propB: 'before'
     }
 
-    const cs = await ChangeSet.calculateModification(after, before);
+    const cs = ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it ('Correctly diffs two resource configs (no-op)', async () => {
+  it ('Correctly diffs two resource configs (no-op)', () => {
     const after = {
       propA: 'prop',
     }
@@ -65,7 +66,7 @@ describe('Change set tests', async () => {
       propA: 'prop',
     }
 
-    const cs = await ChangeSet.calculateModification(after, before);
+    const cs = ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
     expect(cs.operation).to.eq(ResourceOperation.NOOP)
@@ -95,7 +96,7 @@ describe('Change set tests', async () => {
     expect(cs.operation).to.eq(ResourceOperation.DESTROY)
   })
 
-  it ('handles simple arrays', async () => {
+  it ('handles simple arrays', () => {
     const before = {
       propA: ['a', 'b', 'c'],
     }
@@ -104,13 +105,20 @@ describe('Change set tests', async () => {
       propA: ['b', 'a', 'c'],
     }
 
-    const cs = await ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
     expect(cs.operation).to.eq(ResourceOperation.NOOP)
   })
 
-  it('handles simple arrays 2', async () => {
+  it('handles simple arrays 2', () => {
     const after = {
       propA: ['a', 'b', 'c'],
     }
@@ -119,13 +127,20 @@ describe('Change set tests', async () => {
       propA: ['b', 'a'],
     }
 
-    const cs = await ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it('determines the order of operations with canModify 1', async () => {
+  it('determines the order of operations with canModify 1', () => {
     const after = {
       propA: 'after',
     }
@@ -135,14 +150,21 @@ describe('Change set tests', async () => {
       propB: 'before'
     }
 
-    const cs = await ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it('determines the order of operations with canModify 2', async () => {
+  it('determines the order of operations with canModify 2', () => {
     const after = {
       propA: 'after',
     }
@@ -152,10 +174,15 @@ describe('Change set tests', async () => {
       propB: 'before'
     }
 
-    const cs = await ChangeSet.calculateModification<any>(after, before, {
-      propA: { canModify: true },
-      propB: { canModify: true }
-    });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true },
+        propB: { canModify: true }
+      },
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification<any>(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
@@ -163,57 +190,90 @@ describe('Change set tests', async () => {
   })
 
 
-  it('correctly determines array equality', async () => {
+  it('correctly determines array equality', () => {
     const arrA = ['a', 'b', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.operation).to.eq(ResourceOperation.NOOP);
   })
 
-  it('correctly determines array equality 2', async () => {
+  it('correctly determines array equality 2', () => {
     const arrA = ['a', 'b'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
 
-  it('correctly determines array equality 3', async () => {
+  it('correctly determines array equality 3', () => {
     const arrA = ['b', 'a', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
   })
 
-  it('correctly determines array equality 4', async () => {
+  it('correctly determines array equality 4', () => {
     const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
-      propA: {
-        type: 'array',
-        isElementEqual: (a, b) => a.key1 === b.key1
-      }
-    })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
 
-  it('correctly determines array equality 5', async () => {
+  it('correctly determines array equality 5', () => {
     const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
-      propA: {
-        type: 'array',
-        isElementEqual: (a, b) => a.key1 === b.key1
-      }
-    })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
   })

package/src/plan/change-set.ts

@@ -1,7 +1,6 @@
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 
-import { ArrayParameterSetting, ParameterSetting, StatefulParameterSetting } from '../resource/resource-settings.js';
-import { areArraysEqual } from '../utils/utils.js';
+import { ParameterSetting } from '../resource/resource-settings.js';
 
 /**
  * A parameter change describes a parameter level change to a resource.
@@ -85,12 +84,12 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
   }
 
-  static async calculateModification<T extends StringIndexedObject>(
+  static calculateModification<T extends StringIndexedObject>(
     desired: Partial<T>,
     current: Partial<T>,
     parameterSettings: Partial<Record<keyof T, ParameterSetting>> = {},
-  ): Promise<ChangeSet<T>> {
-    const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+  ): ChangeSet<T> {
+    const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
 
     const statefulParameterKeys = new Set(
       Object.entries(parameterSettings)
@@ -126,11 +125,11 @@ export class ChangeSet<T extends StringIndexedObject> {
    * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
    * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
    */
-  private static async calculateParameterChanges<T extends StringIndexedObject>(
+  private static calculateParameterChanges<T extends StringIndexedObject>(
     desiredParameters: Partial<T>,
     currentParameters: Partial<T>,
     parameterOptions?: Partial<Record<keyof T, ParameterSetting>>,
-  ): Promise<ParameterChange<T>[]> {
+  ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
     // Filter out null and undefined values or else the diff below will not work
@@ -155,7 +154,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+      if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: v ?? null,
@@ -210,26 +209,11 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
-  private static async isSame(
+  private static isSame(
     desired: unknown,
     current: unknown,
     setting?: ParameterSetting,
-  ): Promise<boolean> {
-    switch (setting?.type) {
-      case 'stateful': {
-        const statefulSetting = (setting as StatefulParameterSetting).definition.getSettings()
-
-        return ChangeSet.isSame(desired, current, statefulSetting as ParameterSetting);
-      }
-
-      case 'array': {
-        const arrayParameter = setting as ArrayParameterSetting;
-        return areArraysEqual(arrayParameter, desired, current)
-      }
-
-      default: {
-        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
-      }
-    }
+  ): boolean {
+    return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
   }
 }

package/src/plan/plan.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { Plan } from './plan.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestConfig, testPlan, TestResource } from '../utils/test-utils.test.js';
+import { TestConfig, TestResource } from '../utils/test-utils.test.js';
 import { ResourceController } from '../resource/resource-controller.js';
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 import { ResourceSettings } from '../resource/resource-settings.js';
@@ -128,8 +128,8 @@ describe('Plan entity tests', () => {
     ).to.be.true;
   })
 
-  it('Returns the original resource names', async () => {
-    const plan = await Plan.calculate<TestConfig>({
+  it('Returns the original resource names', () => {
+    const plan = Plan.calculate<TestConfig>({
       desiredParameters: { propA: 'propA' },
       currentParametersArray: [{ propA: 'propA2' }],
       stateParameters: null,
@@ -147,8 +147,7 @@ describe('Plan entity tests', () => {
       operation: ResourceOperation.RECREATE
     })
   })
-});
-
+})
 
 function createTestResource() {
   return new class extends TestResource {

package/src/plan/plan.ts

@@ -10,7 +10,6 @@ import { v4 as uuidV4 } from 'uuid';
 
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 import { ArrayParameterSetting, ResourceSettings, StatefulParameterSetting } from '../resource/resource-settings.js';
-import { asyncFilter, asyncIncludes, asyncMap } from '../utils/utils.js';
 import { ChangeSet } from './change-set.js';
 
 /**
@@ -106,14 +105,14 @@ export class Plan<T extends StringIndexedObject> {
     return this.coreParameters.type
   }
 
-  static async calculate<T extends StringIndexedObject>(params: {
+  static calculate<T extends StringIndexedObject>(params: {
     desiredParameters: Partial<T> | null,
     currentParametersArray: Partial<T>[] | null,
     stateParameters: Partial<T> | null,
     coreParameters: ResourceConfig,
     settings: ParsedResourceSettings<T>,
     statefulMode: boolean,
-  }): Promise<Plan<T>> {
+  }): Plan<T> {
     const {
       desiredParameters,
       currentParametersArray,
@@ -131,7 +130,7 @@ export class Plan<T extends StringIndexedObject> {
       statefulMode
     });
 
-    const filteredCurrentParameters = await Plan.filterCurrentParams<T>({
+    const filteredCurrentParameters = Plan.filterCurrentParams<T>({
       desiredParameters,
       currentParameters,
       stateParameters,
@@ -167,7 +166,7 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     // NO-OP, MODIFY or RE-CREATE
-    const changeSet = await ChangeSet.calculateModification(
+    const changeSet = ChangeSet.calculateModification(
       desiredParameters!,
       filteredCurrentParameters!,
       settings.parameterSettings,
@@ -188,13 +187,13 @@ export class Plan<T extends StringIndexedObject> {
    *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
    *  or wants to set. If a parameter is not specified then it's not managed by Codify.
    */
-  private static async filterCurrentParams<T extends StringIndexedObject>(params: {
+  private static filterCurrentParams<T extends StringIndexedObject>(params: {
     desiredParameters: Partial<T> | null,
     currentParameters: Partial<T> | null,
     stateParameters: Partial<T> | null,
     settings: ResourceSettings<T>,
     statefulMode: boolean,
-  }): Promise<Partial<T> | null> {
+  }): Partial<T> | null {
     const {
       desiredParameters: desired,
       currentParameters: current,
@@ -220,12 +219,10 @@ export class Plan<T extends StringIndexedObject> {
 
     // TODO: Add object handling here in addition to arrays in the future
     const arrayStatefulParameters = Object.fromEntries(
-      await asyncMap(
-        Object.entries(filteredCurrent)
-          .filter(([k, v]) => isArrayStatefulParameter(k, v)),
-        async ([k, v]) => [k, await filterArrayStatefulParameter(k, v)],
-      )
-    );
+      Object.entries(filteredCurrent)
+        .filter(([k, v]) => isArrayStatefulParameter(k, v))
+        .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
+    )
 
     return { ...filteredCurrent, ...arrayStatefulParameters }
 
@@ -256,18 +253,31 @@ export class Plan<T extends StringIndexedObject> {
         && Array.isArray(v)
     }
 
-    async function filterArrayStatefulParameter(k: string, v: unknown[]): Promise<unknown[]> {
+    // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
+    function filterArrayStatefulParameter(k: string, v: unknown[]): unknown[] {
       const desiredArray = desired![k] as unknown[];
       const matcher = ((settings.parameterSettings![k] as StatefulParameterSetting)
         .definition
         .getSettings() as ArrayParameterSetting)
-        .isElementEqual;
+        .isElementEqual ?? ((a, b) => a === b);
 
-      const eq = matcher ?? ((a: unknown, b: unknown) => a === b)
+      const desiredCopy = [...desiredArray];
+      const currentCopy = [...v];
+      const result = [];
 
-      return asyncFilter(v, async (cv) =>
-        asyncIncludes(desiredArray, async (dv) => eq(dv, cv))
-      )
+      for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+        const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
+
+        if (idx === -1) {
+          continue;
+        }
+
+        desiredCopy.splice(counter, 1)
+        const [element] = currentCopy.splice(idx, 1)
+        result.push(element)
+      }
+
+      return result;
     }
   }
 

package/src/resource/parsed-resource-settings.ts

@@ -1,14 +1,6 @@
 import { StringIndexedObject } from 'codify-schemas';
 
-import { areArraysEqual } from '../utils/utils.js';
-import {
-  ArrayParameterSetting,
-  ParameterEqualsDefaults,
-  ParameterSetting,
-  ParameterSettingType,
-  ResourceSettings,
-  StatefulParameterSetting
-} from './resource-settings.js';
+import { ParameterSetting, resolveEqualsFn, ResourceSettings, StatefulParameterSetting } from './resource-settings.js';
 import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js'
 
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
@@ -54,7 +46,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       const settings = Object.entries(this.settings.parameterSettings ?? {})
         .map(([k, v]) => [k, v!] as const)
         .map(([k, v]) => {
-          v.isEqual = this.resolveEqualsFn(v, k);
+          v.isEqual = resolveEqualsFn(v, k);
 
           return [k, v];
         })
@@ -154,18 +146,6 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     // The rest of the types have defaults set already
   }
 
-  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => Promise<boolean> | boolean {
-    if (parameter.type === 'array') {
-      return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
-    }
-
-    if (parameter.type === 'stateful') {
-      return this.resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
-    }
-
-    return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
-  }
-
   private getFromCacheOrCreate<T2>(key: string, create: () => T2): T2 {
     if (this.cache.has(key)) {
       return this.cache.get(key) as T2

package/src/resource/resource-controller.test.ts

@@ -99,7 +99,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      await testPlan({
+      testPlan({
         desired: { propA: 'a', propB: 0 },
       })
     )
@@ -116,7 +116,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      await testPlan({
+      testPlan({
         current: [{ propA: 'a', propB: 0 }],
         state: { propA: 'a', propB: 0 },
         statefulMode: true,
@@ -135,7 +135,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      await testPlan({
+      testPlan({
         desired: { propA: 'a', propB: 0 },
         current: [{ propA: 'b', propB: -1 }],
         statefulMode: true

package/src/resource/resource-settings.test.ts

@@ -77,7 +77,7 @@ describe('Resource parameter tests', () => {
     const resourceSpy = spy(resource);
 
     await controller.apply(
-      await testPlan<TestConfig>({
+      testPlan<TestConfig>({
         desired: { propA: 'a', propB: 0, propC: 'c' }
       })
     );
@@ -491,35 +491,4 @@ describe('Resource parameter tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
-
-  it('Works with async equals methods', async () => {
-    const resource = new class extends TestResource {
-      getSettings(): ResourceSettings<TestConfig> {
-        return {
-          id: 'type',
-          parameterSettings: {
-            propA: {
-              isEqual: async (desired, current) => {
-                console.log(desired, current)
-                await sleep(500);
-                return true;
-              }
-            }
-          }
-        }
-      }
-    };
-    const controller = new ResourceController(resource);
-
-    const plan = await controller.plan({ type: 'type', propA: 'abc' } as any);
-
-    console.log(JSON.stringify(plan, null, 2));
-
-    expect(plan.toResponse().operation).to.equal(ResourceOperation.NOOP);
-  })
 })
-
-function sleep(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-

package/src/resource/resource-settings.ts

@@ -1,7 +1,7 @@
 import { StringIndexedObject } from 'codify-schemas';
 import path from 'node:path';
 
-import { untildify } from '../utils/utils.js';
+import { areArraysEqual, untildify } from '../utils/utils.js';
 import { StatefulParameter } from './stateful-parameter.js';
 
 /**
@@ -127,7 +127,7 @@ export interface DefaultParameterSetting {
    *
    * @return Return true if equal
    */
-  isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+  isEqual?: (desired: any, current: any) => boolean;
 
   /**
    * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
@@ -156,7 +156,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    *
    * @return Return true if desired is equivalent to current.
    */
-  isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+  isElementEqual?: (desired: any, current: any) => boolean
 }
 
 /**
@@ -183,10 +183,23 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
   order?: number,
 }
 
-export const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
+const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
   'directory': (a: unknown, b: unknown) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
   'number': (a: unknown, b: unknown) => Number(a) === Number(b),
   'string': (a: unknown, b: unknown) => String(a) === String(b),
   'version': (desired: unknown, current: unknown) => String(current).includes(String(desired))
 }
+
+
+export function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
+  if (parameter.type === 'array') {
+    return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
+  }
+
+  if (parameter.type === 'stateful') {
+    return resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
+  }
+
+  return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
+}

package/src/resource/stateful-parameter.test.ts

@@ -1,13 +1,19 @@
 import { describe, expect, it } from 'vitest';
 import { spy } from 'sinon';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestArrayStatefulParameter, TestConfig, testPlan, TestResource } from '../utils/test-utils.test.js';
-import { ArrayParameterSetting, ResourceSettings } from './resource-settings.js';
+import {
+  TestArrayStatefulParameter,
+  TestConfig,
+  testPlan,
+  TestResource,
+  TestStatefulParameter
+} from '../utils/test-utils.test.js';
+import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
 import { ResourceController } from './resource-controller.js';
 
 describe('Stateful parameter tests', () => {
   it('addItem is called the correct number of times', async () => {
-    const plan = await testPlan<TestConfig>({
+    const plan = testPlan<TestConfig>({
       desired: { propZ: ['a', 'b', 'c'] },
     });
 
@@ -22,7 +28,7 @@ describe('Stateful parameter tests', () => {
   })
 
   it('applyRemoveItem is called the correct number of times', async () => {
-    const plan = await testPlan<TestConfig>({
+    const plan = testPlan<TestConfig>({
       desired: null,
       current: [{ propZ: ['a', 'b', 'c'] }],
       state: { propZ: ['a', 'b', 'c'] },
@@ -41,7 +47,7 @@ describe('Stateful parameter tests', () => {
 
   it('In stateless mode only applyAddItem is called only for modifies', async () => {
     const parameter = new TestArrayStatefulParameter()
-    const plan = await testPlan<TestConfig>({
+    const plan = testPlan<TestConfig>({
       desired: { propZ: ['a', 'c', 'd', 'e', 'f'] }, // b to remove, d, e, f to add
       current: [{ propZ: ['a', 'b', 'c'] }],
       settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: parameter } } },
@@ -50,7 +56,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
     expect(plan.changeSet.parameterChanges[0]).toMatchObject({
       name: 'propZ',
-      previousValue: ['a', 'c'], // In stateless mode the previous value gets filtered to prevent deletes
+      previousValue: ['c', 'a'], // In stateless mode the previous value gets filtered to prevent deletes
       newValue: ['a', 'c', 'd', 'e', 'f'],
       operation: ParameterOperation.MODIFY,
     })
@@ -72,7 +78,7 @@ describe('Stateful parameter tests', () => {
       }
     });
 
-    const plan = await testPlan<TestConfig>({
+    const plan = testPlan<TestConfig>({
       desired: { propZ: ['9.12', '9.13'] }, // b to remove, d, e, f to add
       current: [{ propZ: ['9.12.9'] }],
       settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
@@ -92,31 +98,61 @@ describe('Stateful parameter tests', () => {
     expect(testParameter.removeItem.called).to.be.false;
   })
 
-  it('isElementEqual works being async', async () => {
-    const testParameter = spy(new class extends TestArrayStatefulParameter {
-      getSettings(): ArrayParameterSetting {
+  it('isEqual works with type defaults', () => {
+    const testParameter = spy(new class extends TestStatefulParameter {
+      getSettings(): ParameterSetting {
         return {
-          type: 'array',
-          isElementEqual: async (desired, current) => {
-            console.log(desired, current)
-            await sleep(50);
-            return true;
-          }
+          type: 'version',
         }
       }
     });
 
-    const plan = await testPlan<TestConfig>({
-      desired: { propZ: ['9.12'] }, // b to remove, d, e, f to add
-      current: [{ propZ: ['23472934'] }], // purposely make these two values very different since isElementEqual always returns true
+    const plan = testPlan<TestConfig>({
+      desired: { propZ: '20' },
+      current: [{ propZ: '20.17.0' }],
       settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
     });
 
-    expect(plan.toResponse().operation).to.equal(ResourceOperation.NOOP);
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
-})
 
-function sleep(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+  it('isElementEquals test', async () => {
+    const testParameter = spy(new class extends TestArrayStatefulParameter {
+      getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: (desired, current) => current.includes(desired),
+        }
+      }
+
+      async refresh(): Promise<any> {
+        return [
+          '20.15.0',
+          '20.15.1'
+        ]
+      }
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: { nodeVersions: { type: 'stateful', definition: testParameter } }
+        }
+      }
 
+      async refresh(): Promise<Partial<any> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      nodeVersions: ['20.15'],
+    } as any)
+
+    console.log(JSON.stringify(plan, null, 2))
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+})

package/src/utils/utils.ts

@@ -111,7 +111,7 @@ export function untildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
 
-export async function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
+export function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
   if (!Array.isArray(desired) || !Array.isArray(current)) {
     throw new Error(`A non-array value:
           
@@ -130,12 +130,10 @@ Was provided even though type array was specified.
   const desiredCopy = [...desired];
   const currentCopy = [...current];
 
-  const eq = parameter.isElementEqual ?? ((a, b) => a === b);
-
   // Algorithm for to check equality between two un-ordered; un-hashable arrays using
   // an isElementEqual method. Time: O(n^2)
   for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-    const idx = await asyncFindIndex(currentCopy, (e2) => eq(desiredCopy[counter], e2))
+    const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2))
 
     if (idx === -1) {
       return false;
@@ -147,56 +145,3 @@ Was provided even though type array was specified.
 
   return currentCopy.length === 0;
 }
-
-export async function asyncFilter<T>(arr: T[], filter: (a: T) => Promise<boolean> | boolean): Promise<T[]> {
-  const result = [];
-
-  for (const element of arr) {
-    if (await filter(element)) {
-      result.push(element);
-    }
-  }
-
-  return result;
-}
-
-export async function asyncMap<T, R>(arr: T[], map: (a: T) => Promise<R> | R): Promise<R[]> {
-  const result: R[] = [];
-
-  for (const element of arr) {
-    result.push(await map(element));
-  }
-
-  return result;
-}
-
-
-export async function asyncFindIndex<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<number> {
-  for (const [counter, element] of arr.entries()) {
-    if (await eq(element)) {
-      return counter;
-    }
-  }
-
-  return -1;
-}
-
-export async function asyncFind<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<T | undefined> {
-  for (const element of arr) {
-    if (await eq(element)) {
-      return element;
-    }
-  }
-
-  return undefined;
-}
-
-export async function asyncIncludes<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<boolean> {
-  for (const element of arr) {
-    if (await eq(element)) {
-      return true
-    }
-  }
-
-  return false;
-}