fix(core): update

package.json

@@ -13,15 +13,16 @@
     "format": "(gitzone format)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tstest": "^1.0.52",
-    "@pushrocks/tapbundle": "^3.2.14",
-    "@types/node": "^14.14.35",
+    "@gitzone/tsbuild": "^2.1.29",
+    "@gitzone/tstest": "^1.0.64",
+    "@pushrocks/tapbundle": "^4.0.8",
+    "@types/node": "^17.0.21",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "fast-deep-equal": "^3.1.3"
+    "fast-deep-equal": "^3.1.3",
+    "minimatch": "^5.0.1"
   },
   "browserslist": [
     "last 1 chrome versions"

test/test.both.ts

@@ -10,8 +10,60 @@ tap.test('first test', async () => {
 });
 
 tap.test('should fast deep equal objects', async () => {
-  expect(smartobject.fastDeepEqual({ hello: 'yes' }, { hello: 'yes' })).to.be.true;
-  expect(smartobject.fastDeepEqual({ hello: 'yes' }, { hello: 3 })).to.be.false;
+  expect(smartobject.fastDeepEqual({ hello: 'yes' }, { hello: 'yes' })).toBeTrue();
+  expect(smartobject.fastDeepEqual({ hello: 'yes' }, { hello: 3 })).toBeFalse();
+});
+
+let parentObject: any = {};
+let childObject: any = {};
+
+tap.test('childObject should not yet be in parentObject', async () => {
+  expect(smartobject.exists(parentObject, 'childObject')).toBeFalse();
+  parentObject.childObject = childObject;
+});
+
+tap.test('childObject should now be in parentObject', async () => {
+  expect(smartobject.exists(parentObject, 'childObject')).toBeTrue();
+});
+
+tap.test('should be able to deepAdd an childParam', async () => {
+  const parentObject = {
+    hello: 'there'
+  };
+  const parentObject2 = smartobject.smartAdd(parentObject, 'wow.za', 'yes');
+  console.log(parentObject2);
+  expect(smartobject.exists(parentObject2.wow, 'za')).toBeTrue();
+});
+
+tap.test('should be able to deep get an item', async () => {
+  const testObject = {
+    hey: {
+      there: {
+        so: 'cool'
+      }
+    }
+  };
+
+  const item = smartobject.smartGet(testObject, 'hey.there.so');
+  expect(item).toEqual('cool');
+});
+
+tap.test('should call properties for minimatched properties', async () => {
+  let testObject = {
+    matchedOne: 'Hey!',
+    matchedTwo: 'this works!',
+    notmatched: 'NOT!'
+  };
+
+  const matchedStrings: string[] = [];
+  await smartobject.forEachMinimatch(testObject, 'matched*', matchedProperty => {
+    matchedStrings.push(matchedProperty);
+    console.log(matchedProperty);
+  });
+
+  expect(matchedStrings).toContain('Hey!');
+  expect(matchedStrings).toContain('this works!');
+  expect(matchedStrings).not.toContain('NOT!');
 });
 
 tap.start();

ts/index.ts

@@ -18,13 +18,13 @@ export const compareObjects = (
   comparisonObjectArg: any
 ): IObjectCompareResult => {
   const returnComparisonObject = {
-    missingProperties: [],
-    additionalProperties: [],
-    presentInBothProperties: [],
-    nulledProperties: [],
-    undefinedProperties: [],
-    divergingProperties: [],
-    equalProperties: [],
+    missingProperties: [] as string[],
+    additionalProperties: [] as string[],
+    presentInBothProperties: [] as string[],
+    nulledProperties: [] as string[],
+    undefinedProperties: [] as string[],
+    divergingProperties: [] as string[],
+    equalProperties: [] as string[],
   };
 
   const allProperties = Object.keys(referenceObjectArg).concat(Object.keys(comparisonObjectArg));
@@ -72,12 +72,132 @@ export const compareObjects = (
   }
 
   for (const currentProperty of Object.keys(returnComparisonObject)) {
-    const onlyUnique = (value, index, self) => {
+    const onlyUnique = (value: any, index: number, self: Array<any>) => {
       return self.indexOf(value) === index;
     };
-    const uniqueArray = returnComparisonObject[currentProperty].filter(onlyUnique);
-    returnComparisonObject[currentProperty] = uniqueArray;
+    const uniqueArray = returnComparisonObject[currentProperty as keyof(typeof returnComparisonObject)].filter(onlyUnique);
+    returnComparisonObject[currentProperty as keyof(typeof returnComparisonObject)] = uniqueArray;
   }
 
   return returnComparisonObject;
 };
+
+/**
+ * adds an object to the parent object if it doesn't exists
+ * @param parentObject
+ * @param childParam
+ * @param logBool
+ * @returns {boolean}
+ */
+export const smartAdd = (
+  parentObject: object,
+  childParam: string,
+  valueArg: any = {},
+  optionsArg?: {
+    interpretDotsAsLevel: boolean;
+  }
+): typeof parentObject & any => {
+  optionsArg = {
+    interpretDotsAsLevel: true,
+    ...optionsArg
+  };
+
+  let paramLevels: string[];
+  let referencePointer: any = parentObject;
+  if (optionsArg.interpretDotsAsLevel) {
+    paramLevels = childParam.split('.');
+  } else {
+    paramLevels = [childParam];
+  }
+
+  for (let i = 0; i !== paramLevels.length; i++) {
+    const varName: string = paramLevels[i];
+
+    // is there a next variable ?
+    const varNameNext: string = (() => {
+      if (paramLevels[i + 1]) {
+        return paramLevels[i + 1];
+      }
+      return null;
+    })();
+
+    // build the tree in parentObject
+    if (!referencePointer[varName] && !varNameNext) {
+      referencePointer[varName] = valueArg;
+      referencePointer = null;
+    } else if (!referencePointer[varName] && varNameNext) {
+      referencePointer[varName] = {};
+      referencePointer = referencePointer[varName];
+    } else if (referencePointer[varName] && varNameNext) {
+      referencePointer = referencePointer[varName];
+    } else {
+      throw new Error('Something is strange!');
+    }
+  }
+  return parentObject;
+};
+
+/**
+ * gets an object from the parent object using dots as levels by default
+ * @param parentObject
+ * @param childParam
+ * @param optionsArg
+ */
+export const smartGet = <T>(
+  parentObject: object,
+  childParam: string,
+  optionsArg?: {
+    interpretDotsAsLevel: boolean;
+  }
+): T => {
+  optionsArg = {
+    interpretDotsAsLevel: true,
+    ...optionsArg
+  };
+
+  let paramLevels: string[];
+  if (optionsArg.interpretDotsAsLevel) {
+    paramLevels = childParam.split('.');
+  } else {
+    paramLevels = [childParam];
+  }
+
+  let referencePointer: any = parentObject;
+  for (const level of paramLevels) {
+    if (referencePointer[level as any]) {
+      referencePointer = referencePointer[level as any];
+    } else {
+      return null;
+    }
+  }
+  return referencePointer as T;
+};
+
+/**
+ * checks if an object has a parameter with a given key name, returns true if yes.
+ * @param parentObject
+ * @param childParam
+ * @returns {boolean}
+ */
+export let exists = (parentObject: object, childParam: string): boolean => {
+  if (parentObject.hasOwnProperty(childParam)) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * runs a function for all properties of an object whose key matches a regex expression
+ * @param parentObjectArg the parent object
+ * @param wildcardArg the rege expression to match the property keys against
+ * @param callbackArg the function to run with those properties
+ */
+export let forEachMinimatch = async (parentObjectArg: any, wildcardArg: string, callbackArg: (matchedArg: string) => void) => {
+  let propertyNames = Object.getOwnPropertyNames(parentObjectArg);
+  let propertyNamesMatched = propertyNames.filter(propertyNameArg => {
+    return plugins.minimatch(propertyNameArg, wildcardArg);
+  });
+  for (let propertyNameArg of propertyNamesMatched) {
+    await callbackArg(parentObjectArg[propertyNameArg]);
+  }
+};

ts/smartobject.plugins.ts

@@ -1,4 +1,7 @@
+
+// thirdparty scope
 // tslint:disable-next-line: no-submodule-imports
 import fastDeepEqual from 'fast-deep-equal/es6';
+import minimatch from 'minimatch';
 
-export { fastDeepEqual };
+export { fastDeepEqual, minimatch };