nowjs-core
Version:
NowCanDo Javascript Core [nowjs-core] is a library written by TypeScript code maintains under Apache 2.0 licence
288 lines (287 loc) • 9.42 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.PROPERTY_METADATA_KEY = Symbol('object.property.metadata.key');
exports.PROPERTY_PRESENTATION_KEY = Symbol('object.property.presentation.key');
exports.OBJECT_DISPLAYNAME_METADATA_KEY = Symbol('object.displayName.key');
exports.OBJECT_DISPLAYSHORTNAME_METADATA_KEY = Symbol('object.displayShortName.key');
exports.OBJECT_DISPLAYHINT_METADATA_KEY = Symbol('object.displayHint.key');
exports.OBJECT_DISPLAYORDER_METADATA_KEY = Symbol('object.displayOrder.key');
function deprecated(message = 'The {type} "{name}" is deprecated.') {
return (target, propertyName, descriptor) => {
const original = descriptor.value;
let localMessage = '';
if (typeof message === 'string') {
localMessage = message.replace('{type}', (typeof target).toUpperCase());
localMessage = message.replace('{name}', propertyName);
}
else if (typeof message === 'function') {
localMessage = message('DeprecatedMessage', target, propertyName, original);
}
descriptor.value = (...args) => {
console.warn(localMessage);
return original.apply(target, args);
};
return descriptor;
};
}
function getReflectdDisplayName(target, propertyName, defaultName) {
const name = Reflect.getMetadata(exports.OBJECT_DISPLAYNAME_METADATA_KEY, target, propertyName);
return name ? name : defaultName;
}
exports.getReflectdDisplayName = getReflectdDisplayName;
function displayName(name) {
return (target, propertyName, descriptor) => {
const original = descriptor.value;
let localName = '';
if (typeof name === 'string') {
localName = name;
}
else if (typeof name === 'function') {
localName = name(propertyName, target, propertyName, original);
}
else {
localName = '';
}
Reflect.defineMetadata(exports.OBJECT_DISPLAYNAME_METADATA_KEY, localName, target, propertyName);
};
}
exports.displayName = displayName;
function displayShortName(name) {
return (target, propertyName, descriptor) => {
const original = descriptor.value;
let localName = '';
if (typeof name === 'string') {
localName = name;
}
else if (typeof name === 'function') {
localName = name(propertyName, target, propertyName, original);
}
else {
localName = '';
}
Reflect.defineMetadata(exports.OBJECT_DISPLAYSHORTNAME_METADATA_KEY, localName, target, propertyName);
};
}
exports.displayShortName = displayShortName;
function displayHint(hint) {
return (target, propertyName, descriptor) => {
const original = descriptor.value;
let localName = '';
if (typeof hint === 'string') {
localName = hint;
}
else if (typeof hint === 'function') {
localName = hint(propertyName, target, propertyName, original);
}
else {
localName = '';
}
Reflect.defineMetadata(exports.OBJECT_DISPLAYHINT_METADATA_KEY, localName, target, propertyName);
};
}
exports.displayHint = displayHint;
function displayOrder(num) {
return (target, propertyName, descriptor) => {
Reflect.defineMetadata(exports.OBJECT_DISPLAYHINT_METADATA_KEY, num, target, propertyName);
};
}
exports.displayOrder = displayOrder;
function sealed(constructor) {
Object.seal(constructor);
Object.seal(constructor.prototype);
}
exports.sealed = sealed;
function classDecorator(constructor) {
return class extends constructor {
constructor() {
super(...arguments);
this.newProperty = 'new property';
this.hello = 'override';
}
};
}
exports.classDecorator = classDecorator;
function enumerable(value) {
return (target, propertyKey, descriptor) => {
descriptor.enumerable = value;
};
}
exports.enumerable = enumerable;
function configurable(value) {
return (target, propertyKey, descriptor) => {
descriptor.configurable = value;
};
}
exports.configurable = configurable;
function propertySet(target, propertyKey, descriptor) {
const set = descriptor.set;
descriptor.set = (value) => {
const type = Reflect.getMetadata('design:type', target, propertyKey);
if (!(value instanceof type)) {
throw new TypeError('Invalid type.');
}
set(value);
};
}
exports.propertySet = propertySet;
function readonlyObject(Target) {
const newConstructor = () => {
Target.apply(this);
Object.freeze(this);
};
newConstructor.prototype = Object.create(Target.prototype);
newConstructor.prototype.constructor = Target;
return newConstructor;
}
exports.readonlyObject = readonlyObject;
function defineProperty(target, propertyKey) {
const columns = Reflect.getMetadata(exports.PROPERTY_METADATA_KEY, target.constructor) || [];
columns.push(propertyKey);
Reflect.defineMetadata(exports.PROPERTY_METADATA_KEY, columns, target.constructor);
}
exports.defineProperty = defineProperty;
function extend(first, second) {
const result = {};
for (const id in first) {
result[id] = first[id];
}
for (const id in second) {
if (!result.hasOwnProperty(id)) {
result[id] = second[id];
}
}
return result;
}
exports.extend = extend;
function getProperty(o, name) {
return o[name];
}
exports.getProperty = getProperty;
function setProperty(obj, key, value) {
obj[key] = value;
}
exports.setProperty = setProperty;
function getObjetctNestedPath(theObject, path, separator = '.') {
try {
separator = separator || '.';
return path
.replace('[', separator)
.replace(']', '')
.split(separator)
.reduce((obj, mproperty) => {
return obj[mproperty];
}, theObject);
}
catch (err) {
return undefined;
}
}
exports.getObjetctNestedPath = getObjetctNestedPath;
function getObjectLastParentOfPath(theObject, path, separator) {
try {
separator = separator || '.';
const objPath = path
.replace('[', separator)
.replace(']', '')
.split(separator);
const lastPath = objPath.splice(objPath.length - 1, 1);
return objPath.reduce((obj, mproperty) => {
return obj[mproperty];
}, theObject);
}
catch (err) {
return undefined;
}
}
exports.getObjectLastParentOfPath = getObjectLastParentOfPath;
function getObjectLastKeyOfPath(theObject, path, separator) {
try {
separator = separator || '.';
const objPath = path
.replace('[', separator)
.replace(']', '')
.split(separator);
return objPath[objPath.length - 1];
}
catch (err) {
return undefined;
}
}
exports.getObjectLastKeyOfPath = getObjectLastKeyOfPath;
function isObjectType(item) {
return item && typeof item === 'object' && !Array.isArray(item);
}
exports.isObjectType = isObjectType;
function deepAssign(target, ...sources) {
if (!sources.length)
return target;
const source = sources.shift();
if (isObjectType(target) && isObjectType(source)) {
for (const key in source) {
if (!source.hasOwnProperty(key))
continue;
if (isObjectType(source[key]) && Object.keys(source[key]).length > 0) {
if (!target[key]) {
Object.assign(target, { [key]: {} });
}
deepAssign(target[key], source[key]);
}
else {
Object.assign(target, { [key]: source[key] });
}
}
}
return deepAssign(target, ...sources);
}
exports.deepAssign = deepAssign;
function cloneObject(obj) {
return deepAssign({}, obj);
}
exports.cloneObject = cloneObject;
function toCloneObject(target) {
return cloneObject(target);
}
exports.toCloneObject = toCloneObject;
function toDeepAssign(target, ...sources) {
return deepAssign(target, ...sources);
}
exports.toDeepAssign = toDeepAssign;
function deepEqual(x, y) {
if (x === y) {
return true;
}
else if (typeof x == 'object' && x != null && typeof y == 'object' && y != null) {
if (Object.keys(x).length != Object.keys(y).length)
return false;
for (const prop in x) {
if (y.hasOwnProperty(prop)) {
if (!deepEqual(x[prop], y[prop]))
return false;
}
else
return false;
}
return true;
}
else
return false;
}
exports.deepEqual = deepEqual;
function createInstance(c) {
return new c();
}
exports.createInstance = createInstance;
const groupBy = (fn) => (list) => list.reduce((all, curr) => {
const key = fn(curr);
(all[key] || (all[key] = [])).push(curr);
return all;
}, {});
exports.groupBy = groupBy;
const values = (obj) => Object.values(obj);
exports.values = values;
const pipe = (f1, ...fns) => (...args) => {
return fns.reduce((res, fn) => fn(res), f1.apply(null, args));
};
exports.pipe = pipe;
const path = (nodes) => (obj) => nodes.reduce((o, node) => o[node], obj);
exports.path = path;