@angular-package/property
Version:
Features to handle object properties.
271 lines (261 loc) • 11.8 kB
JavaScript
import { __classPrivateFieldGet, __classPrivateFieldSet } from 'tslib';
const errorCallback = (message, on = false) => {
return (result, value) => {
if (result === on) {
throw new Error(`${message}, got value ${typeof value === 'object' ? JSON.stringify(value) : value}`);
}
return result;
};
};
const callbacks = {
accessor: errorCallback(`Accessor descriptor must be an \`ThisAccessorDescriptor<Value, Obj>\` type`),
data: errorCallback(`Data descriptor must be an \`DataDescriptors<Value>\` type`),
descriptor: errorCallback(`Any kind of descriptor was not found`),
};
var _AccessorDescriptors_descriptor;
class AccessorDescriptors {
constructor(descriptor, callback) {
_AccessorDescriptors_descriptor.set(this, {
configurable: true,
enumerable: true,
});
descriptor && this.set(descriptor, callback);
}
static define(descriptor, callback = callbacks['accessor']) {
const result = Object.assign({
configurable: true,
enumerable: true,
}, Property.pick(descriptor, 'configurable', 'enumerable', 'get', 'set'));
callback && callback(typeof result === 'object', result);
return result;
}
get get() {
return __classPrivateFieldGet(this, _AccessorDescriptors_descriptor, "f");
}
static guard(descriptor, callback = callbacks['accessor']) {
let result = true;
Object
.keys(descriptor)
.forEach(key => (result === true) && (result = key in {
'configurable': true, 'enumerable': true, 'get': true, 'set': true
}));
return callback(result, descriptor);
}
set(descriptor, callback) {
__classPrivateFieldSet(this, _AccessorDescriptors_descriptor, AccessorDescriptors.define(descriptor, callback), "f");
return this;
}
}
_AccessorDescriptors_descriptor = new WeakMap();
var _DataDescriptors_descriptor;
class DataDescriptors {
constructor(descriptor) {
_DataDescriptors_descriptor.set(this, {
configurable: true,
enumerable: true,
writable: true,
value: undefined,
});
descriptor && this.set(descriptor);
}
static define(descriptor, callback) {
const result = Object.assign({
configurable: true,
enumerable: true,
}, Property.pick(descriptor, 'configurable', 'enumerable', 'writable', 'value'));
callback && callback(typeof result === 'object', result);
return result;
}
get get() {
return __classPrivateFieldGet(this, _DataDescriptors_descriptor, "f");
}
static guard(descriptor, callback = callbacks['data']) {
let result = true;
Object
.keys(descriptor)
.forEach(key => (result === true) && (result = key in {
'configurable': true, 'enumerable': true, 'writable': true, 'value': true
}));
return callback(result, descriptor);
}
set(descriptor, callback) {
__classPrivateFieldSet(this, _DataDescriptors_descriptor, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _DataDescriptors_descriptor, "f")), DataDescriptors.define(descriptor, callback)), "f");
return this;
}
}
_DataDescriptors_descriptor = new WeakMap();
var _a, _Descriptor_detectObject;
class Descriptor {
static defineAccessor(descriptor, callback) {
return AccessorDescriptors.define(descriptor, callback);
}
static defineData(descriptor, callback) {
return DataDescriptors.define(descriptor, callback);
}
static get(object, name) {
return (Object.getOwnPropertyDescriptor(object, name) ||
Object.getOwnPropertyDescriptor(__classPrivateFieldGet(this, _a, "m", _Descriptor_detectObject).call(this, object), name));
}
static getAll(object) {
return Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(object)), Object.getOwnPropertyDescriptors(__classPrivateFieldGet(this, _a, "m", _Descriptor_detectObject).call(this, object)));
}
static pick(object, ...names) {
const pickedDescriptors = {};
const descriptors = this.getAll(object);
typeof descriptors === 'object' &&
Object.keys(descriptors)
.filter(key => names.includes(key))
.forEach(key => Object.assign(pickedDescriptors, {
[key]: descriptors[key],
}));
return pickedDescriptors;
}
}
_a = Descriptor, _Descriptor_detectObject = function _Descriptor_detectObject(object) {
return typeof object === 'object'
? object['__proto__']
: object.prototype;
};
var _Descriptors_descriptors;
class Descriptors {
constructor(obj, ...keys) {
_Descriptors_descriptors.set(this, new Map());
Array.isArray(keys) && keys.length > 0
? this.setPicked(obj, ...keys)
: this.setAll(obj);
}
get descriptors() {
return __classPrivateFieldGet(this, _Descriptors_descriptors, "f");
}
get(key) {
return __classPrivateFieldGet(this, _Descriptors_descriptors, "f").get(key);
}
getAll() {
return Array.from(__classPrivateFieldGet(this, _Descriptors_descriptors, "f").entries());
}
has(key) {
return __classPrivateFieldGet(this, _Descriptors_descriptors, "f").has(key);
}
set(key, value) {
__classPrivateFieldGet(this, _Descriptors_descriptors, "f").set(key, value);
return this;
}
setAll(object) {
const objectDescriptors = Descriptor.getAll(object);
typeof objectDescriptors === 'object' &&
Object.keys(objectDescriptors).forEach((key) => __classPrivateFieldGet(this, _Descriptors_descriptors, "f").set(key, objectDescriptors[key]));
return this;
}
setPicked(obj, ...keys) {
const pickedDescriptors = Descriptor.pick(obj, ...keys);
typeof pickedDescriptors === 'object' &&
Object.keys(pickedDescriptors).forEach((key) => __classPrivateFieldGet(this, _Descriptors_descriptors, "f").set(key, pickedDescriptors[key]));
return this;
}
}
_Descriptors_descriptors = new WeakMap();
var _WrapProperty_instances, _WrapProperty_descriptors, _WrapProperty_object, _WrapProperty_wrapped, _WrapProperty_wrappedValues, _WrapProperty_wrap;
class WrapProperty {
constructor(object, ...names) {
_WrapProperty_instances.add(this);
_WrapProperty_descriptors.set(this, void 0);
_WrapProperty_object.set(this, void 0);
_WrapProperty_wrapped.set(this, new Set());
_WrapProperty_wrappedValues.set(this, new Map());
__classPrivateFieldSet(this, _WrapProperty_object, object, "f");
__classPrivateFieldSet(this, _WrapProperty_descriptors, new Descriptors(object, ...names), "f");
}
get descriptors() {
return __classPrivateFieldGet(this, _WrapProperty_descriptors, "f");
}
get wrapped() {
return __classPrivateFieldGet(this, _WrapProperty_wrapped, "f");
}
get wrappedValues() {
return __classPrivateFieldGet(this, _WrapProperty_wrappedValues, "f");
}
wrap(names, getterCallback, setterCallback) {
Array.isArray(names)
? names.forEach(name => __classPrivateFieldGet(this, _WrapProperty_instances, "m", _WrapProperty_wrap).call(this, __classPrivateFieldGet(this, _WrapProperty_object, "f"), name, getterCallback, setterCallback))
: __classPrivateFieldGet(this, _WrapProperty_instances, "m", _WrapProperty_wrap).call(this, __classPrivateFieldGet(this, _WrapProperty_object, "f"), names, getterCallback, setterCallback);
return this;
}
unwrap(...names) {
Array.isArray(names) &&
names.forEach((name) => (__classPrivateFieldGet(this, _WrapProperty_wrapped, "f").delete(name),
Object.defineProperty(__classPrivateFieldGet(this, _WrapProperty_object, "f"), name, Object.assign({}, __classPrivateFieldGet(this, _WrapProperty_descriptors, "f").get(name)))));
return this;
}
}
_WrapProperty_descriptors = new WeakMap(), _WrapProperty_object = new WeakMap(), _WrapProperty_wrapped = new WeakMap(), _WrapProperty_wrappedValues = new WeakMap(), _WrapProperty_instances = new WeakSet(), _WrapProperty_wrap = function _WrapProperty_wrap(object, name, getterCallback, setterCallback) {
const thisInstance = this;
if (__classPrivateFieldGet(this, _WrapProperty_wrapped, "f").has(name) === false) {
if (typeof object === 'object' || typeof object === 'function') {
__classPrivateFieldGet(this, _WrapProperty_descriptors, "f").has(name) === false &&
__classPrivateFieldGet(this, _WrapProperty_descriptors, "f").setPicked(object, name);
const detectedSource = typeof object === 'function' ? object.prototype : object;
__classPrivateFieldGet(this, _WrapProperty_wrappedValues, "f").set(name, detectedSource[name]);
Object.defineProperty(detectedSource, name, {
configurable: true,
enumerable: false,
get() {
var _a, _b;
let result;
thisInstance.descriptors.has(name) &&
((_b = (_a = thisInstance.descriptors
.get(name)) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.apply(this, arguments));
typeof getterCallback === 'function' &&
(result = getterCallback(name, this));
return result || thisInstance.wrappedValues.get(name);
},
set(value) {
var _a, _b;
const oldValue = thisInstance.wrappedValues.get(name);
thisInstance.descriptors.has(name) &&
((_b = (_a = thisInstance.descriptors
.get(name)) === null || _a === void 0 ? void 0 : _a.set) === null || _b === void 0 ? void 0 : _b.apply(this, arguments));
thisInstance.wrappedValues.set(name, value);
typeof setterCallback === 'function' &&
setterCallback(value, oldValue, name, this);
},
});
__classPrivateFieldGet(this, _WrapProperty_wrapped, "f").add(name);
}
else {
throw new Error(`Problem: Argument \`object\`: ${object} must be generic type variable \`Obj\`.
Quick fix: Check the passed object in the constructor.
`);
}
}
else {
throw new Error(`Problem: Property \`name\`: ${String(name)} is already wrapped.`);
}
return this;
};
class Property extends WrapProperty {
static define(object, name, data, accessor) {
typeof data === 'object'
? Object.defineProperty(object, name, data)
: typeof accessor === 'object' &&
Object.defineProperty(object, name, accessor);
return object;
}
static set(object, name, value) {
object[name] = value;
return this;
}
static get(object, name) {
return object[name];
}
static pick(object, ...names) {
return Object.assign({}, ...names.map(key => typeof object[key] !== 'undefined' ? { [key]: object[key] } : undefined));
}
static wrap(object, names, getterCallback, setterCallback) {
return new WrapProperty(object, ...names).wrap(names, getterCallback, setterCallback);
}
constructor(object, ...names) {
super(object, ...names);
}
}
export { Descriptor, Descriptors, Property, WrapProperty };
//# sourceMappingURL=angular-package-property.mjs.map