fix(core): update

This commit is contained in:
Philipp Kunz 2022-03-06 11:09:53 +01:00
parent 1ccc67215c
commit a7c12795fb
5 changed files with 19220 additions and 3353 deletions

22315
package-lock.json generated

File diff suppressed because it is too large Load Diff

View File

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

View File

@ -10,8 +10,60 @@ tap.test('first test', async () => {
}); });
tap.test('should fast deep equal objects', 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: 'yes' })).toBeTrue();
expect(smartobject.fastDeepEqual({ hello: 'yes' }, { hello: 3 })).to.be.false; 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(); tap.start();

View File

@ -18,13 +18,13 @@ export const compareObjects = (
comparisonObjectArg: any comparisonObjectArg: any
): IObjectCompareResult => { ): IObjectCompareResult => {
const returnComparisonObject = { const returnComparisonObject = {
missingProperties: [], missingProperties: [] as string[],
additionalProperties: [], additionalProperties: [] as string[],
presentInBothProperties: [], presentInBothProperties: [] as string[],
nulledProperties: [], nulledProperties: [] as string[],
undefinedProperties: [], undefinedProperties: [] as string[],
divergingProperties: [], divergingProperties: [] as string[],
equalProperties: [], equalProperties: [] as string[],
}; };
const allProperties = Object.keys(referenceObjectArg).concat(Object.keys(comparisonObjectArg)); const allProperties = Object.keys(referenceObjectArg).concat(Object.keys(comparisonObjectArg));
@ -72,12 +72,132 @@ export const compareObjects = (
} }
for (const currentProperty of Object.keys(returnComparisonObject)) { 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; return self.indexOf(value) === index;
}; };
const uniqueArray = returnComparisonObject[currentProperty].filter(onlyUnique); const uniqueArray = returnComparisonObject[currentProperty as keyof(typeof returnComparisonObject)].filter(onlyUnique);
returnComparisonObject[currentProperty] = uniqueArray; returnComparisonObject[currentProperty as keyof(typeof returnComparisonObject)] = uniqueArray;
} }
return returnComparisonObject; 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]);
}
};

View File

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