ts-comply
Version:
TypeTools is a Typescript library for providing extensible tooling runtime validations and type helpers.
680 lines • 25.5 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.isModelCollection = exports.isModelInstance = exports.isObject = exports.isArray = exports.isFunction = exports.isUndef = exports.Ref = exports.ModelDict = exports.ModelList = exports.Dict = exports.List = exports.proxiedObjectsHandler = exports.DataAddress = exports.UnknownClass = exports.settingsInitialize = exports.TypeToolsBase = exports.TypeToolsSettings = exports.refHead = void 0;
var context_1 = require("./context");
var common_iface_1 = require("./upstream/common.iface");
var typeCaches = {};
var stackTraces = {};
var skeletonInstances = {};
var sampleInstances = {};
exports.refHead = '$ref';
var TypeToolsSettings = exports.TypeToolsSettings = (function () {
function TypeToolsSettings(init) {
this.typeToolsKey = TypeToolsSettings.typeToolsKey;
if (init) {
Object.assign(this, init);
}
}
TypeToolsSettings.typeToolsKey = '__type_tools';
return TypeToolsSettings;
}());
var TypeToolsBase = exports.TypeToolsBase = (function () {
function TypeToolsBase(settings) {
if (!settings) {
this.settings = TypeToolsSettings;
}
else {
this.settings = Object.assign(new TypeToolsSettings(), settings);
}
}
TypeToolsBase.getExtension = function (target, extensionName, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
if (!target) {
if (context_1.Context.throwErrors) {
throw TypeToolsBase.reusedTrace('TypeToolsBase.getExtension', "Cannot get TypeToolsBase extension '".concat(extensionName, "' from a null target instance."));
}
return null;
}
var allExtensions = target[settings.typeToolsKey];
return allExtensions ? allExtensions[extensionName] : null;
};
TypeToolsBase.isInitialized = function (target, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
var allExtensions = target[settings.typeToolsKey];
return allExtensions ? allExtensions.initialized : null;
};
TypeToolsBase.setInitialized = function (target, value, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
var allExtensions = target[settings.typeToolsKey];
if (allExtensions) {
allExtensions.initialized = value;
}
};
TypeToolsBase.typeCheck = function (target, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
if (!target) {
return false;
}
return target[settings.typeToolsKey] || target['_get_args'] || target['_tt_define'] ? true : false;
};
TypeToolsBase.addExtension = function (target, extensionName, extension, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
var allExtensions = target[settings.typeToolsKey];
if (!allExtensions) {
allExtensions = TypeToolsBase.init(target, settings);
}
allExtensions[extensionName] = extension;
};
TypeToolsBase.checkContext = function (type) {
if (context_1.Context.location !== 'all' && context_1.runtimeLocation !== context_1.Context.location) {
return false;
}
if (type && context_1.Context.disabledExtensions[(0, common_iface_1.typeFullName)(type)]) {
return false;
}
if (!context_1.Context.current) {
throw TypeToolsBase.reusedTrace('TypeToolsBase.checkContext', "TypeToolsBase library features must be accessed within 'defineFor' block.", true);
}
return true;
};
TypeToolsBase.getSkeleton = function (type) {
var typename = (0, common_iface_1.typeLocalName)(type);
var inst = skeletonInstances[typename];
if (!inst) {
skeletonInstances[typename] = {};
var gettingSkelPrev = context_1.Context.gettingSkeleton;
context_1.Context.gettingSkeleton = true;
var defineDisabledPrev = context_1.Context.defineDisabled;
try {
context_1.Context.defineDisabled = true;
inst = skeletonInstances[typename] = new type();
Object.defineProperty(skeletonInstances[typename], '__tt_keys', { value: Object.keys(skeletonInstances[typename]) });
}
catch (e) { }
context_1.Context.gettingSkeleton = gettingSkelPrev;
context_1.Context.defineDisabled = defineDisabledPrev;
}
return inst;
};
TypeToolsBase.getSampleInstance = function (type) {
var typename = (0, common_iface_1.typeLocalName)(type);
var inst = sampleInstances[typename];
if (!inst) {
sampleInstances[typename] = {};
var gettingSamplePrev = context_1.Context.gettingSampleInstance;
context_1.Context.gettingSampleInstance = true;
try {
inst = sampleInstances[typename] = new type();
Object.defineProperty(sampleInstances[typename], '__tt_keys', { value: Object.keys(sampleInstances[typename]) });
}
catch (e) {
throw e;
}
context_1.Context.gettingSampleInstance = gettingSamplePrev;
}
return inst;
};
TypeToolsBase.typeCacheSet = function (type, key, value) {
var typename = (0, common_iface_1.typeLocalName)(type);
var inst = typeCaches[typename];
if (!inst) {
inst = typeCaches[typename] = {};
}
inst[key] = value;
};
TypeToolsBase.typeCacheGet = function (type, key) {
var typename = (0, common_iface_1.typeLocalName)(type);
var inst = typeCaches[typename];
if (!inst) {
inst = typeCaches[typename] = {};
}
return inst[key];
};
TypeToolsBase.memberTrackParent = function (member, parent, override) {
if (override === void 0) { override = false; }
if (!member) {
return;
}
if (typeof member === 'object') {
var tp = member[TypeToolsSettings.typeToolsKey];
if (tp) {
if (tp.parent) {
if (override) {
tp.parent = parent;
}
return;
}
else {
tp.parent = parent;
}
}
else if (!tp) {
for (var _i = 0, _a = Object.keys(member); _i < _a.length; _i++) {
var key = _a[_i];
if (member[key]) {
TypeToolsBase.memberTrackParent(member[key], parent, override);
}
}
}
}
else if (Array.isArray(member)) {
for (var _b = 0, member_1 = member; _b < member_1.length; _b++) {
var member2 = member_1[_b];
TypeToolsBase.memberTrackParent(member2, parent, override);
}
}
};
TypeToolsBase.init = function (target, settings) {
if (settings === void 0) { settings = TypeToolsSettings; }
if (!target[settings.typeToolsKey]) {
Object.defineProperty(target, settings.typeToolsKey, { value: {} });
}
return target[settings.typeToolsKey];
};
TypeToolsBase.reusedTrace = function (locationName, message, isStatic) {
if (isStatic === void 0) { isStatic = false; }
if (!message) {
message = '';
}
var trace = stackTraces[locationName];
if (!trace) {
trace = stackTraces[locationName] = new Error(message);
}
if (!isStatic) {
trace.message = message;
}
TypeToolsBase.topError = trace;
return trace;
};
TypeToolsBase.trace = function (locationName, message) {
var trace = stackTraces[locationName];
if (!trace) {
trace = stackTraces[locationName] = new Error(message);
}
TypeToolsBase.topError = trace;
return trace;
};
TypeToolsBase.addMetaProperty = function (target, metaKVM, reset) {
if (reset === void 0) { reset = false; }
if (!target) {
return;
}
if (!target._meta) {
Object.defineProperty(target, '_meta', { value: {}, configurable: true, writable: true });
}
if (reset) {
target._meta = {};
}
if (metaKVM) {
for (var _i = 0, _a = Object.keys(metaKVM); _i < _a.length; _i++) {
var key = _a[_i];
target._meta[key] = metaKVM[key];
}
}
return target._meta;
};
TypeToolsBase.addPredefine = function (type, predefiner, prepend) {
if (prepend === void 0) { prepend = false; }
if (!type.predefines) {
type.predefines = [];
}
if (prepend) {
type.predefines.shift(predefiner);
}
else {
type.predefines.push(predefiner);
}
};
TypeToolsBase.addPostdefine = function (type, postdefiner, prepend) {
if (prepend === void 0) { prepend = false; }
if (!type.postdefines) {
type.postdefines = [];
}
if (prepend) {
type.postdefines.shift(postdefiner);
}
else {
type.postdefines.push(postdefiner);
}
};
TypeToolsBase.prototype.addExtension = function (target, extension) {
return TypeToolsBase.addExtension(target, extension, this.settings);
};
TypeToolsBase.prototype.getExtension = function (target) {
return TypeToolsBase.getExtension(target, this.settings);
};
TypeToolsBase.prototype.init = function (target) {
return TypeToolsBase.init(target, this.settings);
};
TypeToolsBase.slowResolveContext = false;
return TypeToolsBase;
}());
function settingsInitialize(type, init) {
if (!init) {
return type;
}
else {
return Object.assign(new type(), init);
}
}
exports.settingsInitialize = settingsInitialize;
var UnknownClass = (function () {
function UnknownClass() {
this.unknown = true;
}
return UnknownClass;
}());
exports.UnknownClass = UnknownClass;
var DataAddress = (function () {
function DataAddress() {
}
DataAddress.prototype.serialize = function () {
return "".concat(this.protocol, "://").concat(this.domain).concat(this.path).concat(this.accessor ? '?a=' + this.accessor : '');
};
return DataAddress;
}());
exports.DataAddress = DataAddress;
exports.proxiedObjectsHandler = {
List: function (args) {
var enabled = true;
var data = {};
var nudge = function (o, p, v) {
if (!args.parent || !args.prop) {
return;
}
context_1.Context.validationError = null;
try {
args.parent[args.prop] = args.parent[args.prop];
}
catch (e) {
context_1.Context.validationError = e;
}
if (context_1.Context.validationError) {
var e = context_1.Context.validationError;
context_1.Context.validationError = null;
if (isNaN(p)) {
if (data.prev && data.prev.p === p) {
var old = data.prev.v;
var len = old.len;
enabled = false;
o.length = len;
for (var i = 0; i < len; ++i) {
o[i] = old[i];
}
while (o.length > 0 && isUndef(o[o.length - 1])) {
o.pop();
}
while (o.length > 0 && isUndef(o[0])) {
o.shift();
}
enabled = true;
}
}
else {
if (data.prevSet && data.prevSet.p === p) {
enabled = false;
o.length = data.prevSet.len;
o[p] = data.prevSet.v;
while (o.length > 0 && isUndef(o[o.length - 1])) {
o.pop();
}
while (o.length > 0 && isUndef(o[0])) {
o.shift();
}
enabled = true;
}
}
}
};
return {
set: function (o, p, v) {
data.prevSet = { p: p, v: o[p], len: o.length };
if (args.type && v && v.constructor.name === 'Object') {
var cast = context_1.Context.cast(v, args.type);
if (cast) {
v = cast;
}
}
o[p] = v;
if (enabled) {
nudge(o, p, v);
}
data.prevSet = null;
return true;
},
get: function (o, p) {
if (p === '_get_args') {
return args;
}
if (p === '_get_args_type') {
return args.type;
}
if (p === '_stencil') {
return function (newTarget, newData) {
return new List(JSON.parse(JSON.stringify(newData)), newTarget, args.prop, args.type, args.order);
};
}
if (p === '_set_args') {
return function (props) { Object.assign(args, props); };
}
switch (p) {
case 'push':
case 'pop':
case 'reverse':
case 'shift':
case 'unshift':
case 'splice':
case 'sort':
return function () {
var a = [];
for (var _i = 0; _i < arguments.length; _i++) {
a[_i] = arguments[_i];
}
if (args.type) {
if (p === 'push' || p === 'unshift') {
if (a[0] && a[0].constructor.name === 'Object') {
var cast = context_1.Context.cast(a[0], args.type);
if (cast) {
a[0] = cast;
}
}
}
if (p === 'splice' && a.length > 2) {
for (var i = 2; i < a.length; ++i) {
if (a[i] && a[i].constructor.name === 'Object') {
var cast = context_1.Context.cast(a[i], args.type);
if (cast) {
a[i] = cast;
}
}
}
}
}
data.prev = { p: p, v: o.concat([]) };
var result = o[p].apply(o, a);
if (enabled) {
nudge(o, p);
}
data.prev = null;
return result;
};
}
return o[p];
},
deleteProperty: function (o, p) {
if (enabled) {
nudge(o, p);
}
return true;
}
};
},
Dict: function (args) {
if (!args.rubric) {
args.rubric = {};
}
var enabled = true;
var data = {};
var nudge = function (o, p, v) {
if (!args.parent || !args.prop) {
return;
}
context_1.Context.validationError = null;
try {
args.parent[args.prop] = args.parent[args.prop];
}
catch (e) {
context_1.Context.validationError = e;
}
if (context_1.Context.validationError) {
var e = context_1.Context.validationError;
context_1.Context.validationError = null;
if (data.prevSet && data.prevSet.p === p) {
enabled = false;
o[p] = data.prevSet.v;
enabled = true;
}
}
};
return {
set: function (o, p, v) {
data.prevSet = { p: p, v: o[p], len: o.length };
if (args.rubric[p] && v && v.constructor.name === 'Object') {
var cast = context_1.Context.cast(v, args.rubric[p]);
if (cast) {
v = cast;
}
}
o[p] = v;
if (enabled) {
nudge(o, p, v);
}
data.prevSet = null;
return true;
},
get: function (o, p) {
if (p === '_get_args') {
return args;
}
if (p === '_get_args_rubric') {
return args.rubric;
}
if (p === '_stencil') {
return function (newTarget, newData) {
return new Dict(JSON.parse(JSON.stringify(newData)), newTarget, args.prop, args.rubric);
};
}
if (p === '_set_args') {
return function (props) { Object.assign(args, props); };
}
if (p === '_nudge') {
return function () { if (enabled) {
nudge(o, p);
} };
}
return o[p];
},
deleteProperty: function (o, p) {
if (enabled) {
nudge(o, p);
}
return true;
}
};
},
};
var List = exports.List = (function (_super) {
__extends(List, _super);
function List(init, parent, prop, type, order) {
if (order === void 0) { order = 1; }
var _this = _super.call(this) || this;
var prox = new Proxy(_this, exports.proxiedObjectsHandler.List({ parent: parent, prop: prop, type: type, order: order }));
if (init && Array.isArray(init)) {
prox.length = init.length;
for (var i = 0; i < init.length; ++i) {
prox[i] = init[i];
}
}
return prox;
}
List.stencil = function (list, newData, newTarget) {
if (!newTarget) {
newTarget = list._get_args.parent;
}
return list._stencil(newTarget, newData);
};
List.check = function (list, type, disallowNull) {
if (disallowNull === void 0) { disallowNull = false; }
if (list === null || list === undefined) {
return true;
}
if (!list) {
return false;
}
if (!Array.isArray(list)) {
return false;
}
if (!type) {
type = list._get_args_type;
}
for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
var el = list_1[_i];
if (List.checkElement(el, type, disallowNull)) {
continue;
}
return false;
}
return true;
};
List.checkElement = function (el, type, disallowNull) {
if (disallowNull === void 0) { disallowNull = false; }
if (!disallowNull && (el === undefined || el === null)) {
return true;
}
if (typeof el === 'string') {
if (type && el.startsWith("".concat(exports.refHead, ".").concat((0, common_iface_1.typeFullName)(type), ":"))) {
return true;
}
else if (el.startsWith("".concat(exports.refHead, ":"))) {
return true;
}
else {
return false;
}
}
if (type && context_1.Context.lineageHas(el, type)) {
if (type.check && !type.check(el)) {
return false;
}
return true;
}
return false;
};
List.currentOp = null;
return List;
}(Array));
var Dict = exports.Dict = (function () {
function Dict(init, parent, prop, rubric) {
var prox = new Proxy(this, exports.proxiedObjectsHandler.Dict({ parent: parent, prop: prop, rubric: rubric }));
if (init) {
Object.assign(this, init);
}
return prox;
}
Dict.typed = function (a) { return a; };
Dict.stencil = function (dict, newData, newTarget) {
if (!newTarget) {
newTarget = dict._get_args.parent;
}
return dict._stencil(newTarget, newData);
};
Dict.check = function (dict, rubric, disallowNull) {
if (disallowNull === void 0) { disallowNull = false; }
if (dict === null || dict === undefined) {
return true;
}
if (!dict) {
return false;
}
if (!dict._get_args_rubric) {
return false;
}
if (!rubric) {
rubric = dict._get_args_rubric;
}
for (var _i = 0, _a = Object.keys(dict); _i < _a.length; _i++) {
var key = _a[_i];
if (!rubric[key]) {
continue;
}
if (Dict.checkElement(dict[key], rubric ? rubric[key] : null, disallowNull)) {
continue;
}
return false;
}
return true;
};
Dict.checkElement = function (el, type, disallowNull) {
if (disallowNull === void 0) { disallowNull = false; }
if (!disallowNull && (el === undefined || el === null)) {
return true;
}
if (el._get_args_rubric) {
return Dict.check(el, el._get_args_rubric, disallowNull);
}
if (typeof el === 'string') {
if (type && el.startsWith("".concat(exports.refHead, ".").concat((0, common_iface_1.typeFullName)(type), ":"))) {
return true;
}
else if (el.startsWith("".concat(exports.refHead, ":"))) {
return true;
}
else {
return false;
}
}
if (type && context_1.Context.lineageHas(el, type)) {
if (type.check && !type.check(el)) {
return false;
}
return true;
}
return false;
};
Dict.currentOp = null;
return Dict;
}());
function ModelList(type, init, parent, prop, order) {
if (order === void 0) { order = 1; }
if (!init) {
init = [];
}
return new List(init, parent, prop, type, order);
}
exports.ModelList = ModelList;
function ModelDict(init, parent, prop, rubric) {
return new Dict(init, parent, prop, rubric);
}
exports.ModelDict = ModelDict;
var Ref = (function () {
function Ref(type, address) {
this.type = type;
this.address = address;
}
Ref.prototype.dereference = function () {
return;
};
Ref.prototype.toJSON = function () {
return { $ref: this.address };
};
return Ref;
}());
exports.Ref = Ref;
function isUndef(a) { return a === undefined || a === null; }
exports.isUndef = isUndef;
function isFunction(a) { return a && a.apply && a.call; }
exports.isFunction = isFunction;
function isArray(a) { return Array.isArray(a); }
exports.isArray = isArray;
function isObject(a) { return a && typeof a === 'object'; }
exports.isObject = isObject;
function isModelInstance(a) { return a && typeof a === 'object' && TypeToolsBase.typeCheck(a); }
exports.isModelInstance = isModelInstance;
function isModelCollection(a) { return a && typeof a === 'object' && TypeToolsBase.typeCheck(a) && a._get_args; }
exports.isModelCollection = isModelCollection;
//# sourceMappingURL=type-tools.js.map