@bitblit/ratchet-misc 4.0.80-alpha

package/dist/cjs/build/ratchet-misc-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetMiscInfo = void 0;
+class RatchetMiscInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetMiscInfo = RatchetMiscInfo;

package/dist/cjs/handlebars/handlebars-ratchet.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlebarsRatchet = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class HandlebarsRatchet {
+    constructor() { }
+    static functionMap() {
+        return {
+            eq: HandlebarsRatchet.equal,
+            ne: HandlebarsRatchet.notEqual,
+            lt: HandlebarsRatchet.lessThan,
+            gt: HandlebarsRatchet.greaterThan,
+            lte: HandlebarsRatchet.lessThanEqual,
+            gte: HandlebarsRatchet.greaterThanEqual,
+            and: HandlebarsRatchet.and,
+            or: HandlebarsRatchet.or,
+            formatBytes: HandlebarsRatchet.formatBytes,
+            rpn: HandlebarsRatchet.reversePolishNotation,
+            add: HandlebarsRatchet.add,
+            sub: HandlebarsRatchet.sub,
+            mul: HandlebarsRatchet.mul,
+            div: HandlebarsRatchet.div,
+            mod: HandlebarsRatchet.mod,
+            maxNum: HandlebarsRatchet.maxNum,
+            minNum: HandlebarsRatchet.minNum,
+        };
+    }
+    static registerAll(handlebars) {
+        handlebars.registerHelper(HandlebarsRatchet.functionMap());
+    }
+    static add(v1, v2) {
+        return ratchet_common_2.NumberRatchet.safeNumber(v1) + ratchet_common_2.NumberRatchet.safeNumber(v2);
+    }
+    static sub(v1, v2) {
+        return ratchet_common_2.NumberRatchet.safeNumber(v1) - ratchet_common_2.NumberRatchet.safeNumber(v2);
+    }
+    static mul(v1, v2) {
+        return ratchet_common_2.NumberRatchet.safeNumber(v1) * ratchet_common_2.NumberRatchet.safeNumber(v2);
+    }
+    static div(v1, v2) {
+        return ratchet_common_2.NumberRatchet.safeNumber(v1) / ratchet_common_2.NumberRatchet.safeNumber(v2);
+    }
+    static mod(v1, v2) {
+        return ratchet_common_2.NumberRatchet.safeNumber(v1) % ratchet_common_2.NumberRatchet.safeNumber(v2);
+    }
+    static equal(v1, v2) {
+        return v1 === v2;
+    }
+    static notEqual(v1, v2) {
+        return v1 !== v2;
+    }
+    static lessThan(v1, v2) {
+        return v1 < v2;
+    }
+    static lessThanEqual(v1, v2) {
+        return v1 <= v2;
+    }
+    static greaterThan(v1, v2) {
+        return v1 > v2;
+    }
+    static greaterThanEqual(v1, v2) {
+        return v1 >= v2;
+    }
+    static maxNum(...args) {
+        return Math.max(...args.slice(0, -1));
+    }
+    static minNum(...args) {
+        return Math.min(...args.slice(0, -1));
+    }
+    static and(...args) {
+        return Array.prototype.every.call(args, Boolean);
+    }
+    static or(...args) {
+        return Array.prototype.slice.call(args, 0, -1).some(Boolean);
+    }
+    static formatBytes(v1) {
+        return ratchet_common_1.StringRatchet.formatBytes(v1);
+    }
+    static reversePolishNotation(...args) {
+        var _a;
+        let rval = null;
+        try {
+            const fns = Object.assign({}, HandlebarsRatchet.functionMap());
+            delete fns['formatBytes'];
+            const stack = [];
+            for (let i = 0; i < args.length - 1; i++) {
+                const a = args[i];
+                if (fns[a]) {
+                    if (stack.length > 1) {
+                        const op2 = stack.pop();
+                        const op1 = stack.pop();
+                        const res = fns[a](op1, op2, {});
+                        stack.push(res);
+                    }
+                    else {
+                        ratchet_common_3.ErrorRatchet.throwFormattedErr('Cannot execute operation %s - not enough args', a);
+                    }
+                }
+                else {
+                    stack.push(a);
+                }
+            }
+            rval = stack.pop();
+        }
+        catch (err) {
+            ratchet_common_4.Logger.error('Failed to execute RPN: %s', err, err);
+            rval = ((_a = ratchet_common_3.ErrorRatchet.asErr(err)) === null || _a === void 0 ? void 0 : _a.message) || 'Failure';
+        }
+        return rval;
+    }
+}
+exports.HandlebarsRatchet = HandlebarsRatchet;

package/dist/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build/ratchet-misc-info"), exports);
+tslib_1.__exportStar(require("./handlebars/handlebars-ratchet"), exports);
+tslib_1.__exportStar(require("./model-validator/model-validator"), exports);
+tslib_1.__exportStar(require("./rxjs/observable-ratchet"), exports);
+tslib_1.__exportStar(require("./rxjs/rxjs-ratchet"), exports);

package/dist/cjs/model-validator/model-validator.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelValidator = void 0;
+const tslib_1 = require("tslib");
+const swagger_model_validator_1 = tslib_1.__importDefault(require("swagger-model-validator"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class ModelValidator {
+    constructor(allModels) {
+        this.allModels = allModels;
+        if (!allModels || Object.keys(allModels).length == 0) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot create model validator, passed models was null/empty : %j', allModels);
+        }
+    }
+    static createFromYamlString(yamlString, rootPath) {
+        const src = js_yaml_1.default.load(yamlString);
+        const modelSrc = rootPath && rootPath.length > 0 ? ratchet_common_1.MapRatchet.findValue(src, rootPath) : src;
+        return ModelValidator.createFromParsedObject(modelSrc);
+    }
+    static createFromParsedObject(parsedObject) {
+        return new ModelValidator(parsedObject);
+    }
+    get modelNames() {
+        return Object.keys(this.allModels);
+    }
+    addModel(modelName, model) {
+        this.allModels[modelName] = model;
+    }
+    fetchModel(modelName) {
+        return this.allModels[modelName];
+    }
+    validate(modelName, modelObject, emptyAllowed = false, extraPropertiesAllowed = true) {
+        let rval = [];
+        ratchet_common_1.Logger.silly('Validating model %s all definitions are : %j', modelName, this.allModels);
+        const modelEmpty = !modelObject || Object.keys(modelObject).length === 0;
+        if (modelEmpty) {
+            if (!emptyAllowed) {
+                rval.push('Empty / null object sent, but empty not allowed here');
+            }
+        }
+        else {
+            if (this.allModels && modelName && this.allModels[modelName]) {
+                const validation = new swagger_model_validator_1.default().validate(modelObject, this.allModels[modelName], this.allModels, emptyAllowed, extraPropertiesAllowed);
+                if (validation.errorCount > 0) {
+                    rval = validation.errors.map((e) => e.message);
+                }
+            }
+            else {
+                rval = ['Model named "' + modelName + '" not present in schema'];
+            }
+        }
+        return rval;
+    }
+}
+exports.ModelValidator = ModelValidator;

package/dist/cjs/rxjs/observable-ratchet.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableRatchet = void 0;
+const rxjs_1 = require("rxjs");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class ObservableRatchet {
+    static timeout(srcObservable, title, timeoutMillis) {
+        const rval = (0, rxjs_1.race)(srcObservable, this.createTimeoutObservable(title, timeoutMillis));
+        return rval;
+    }
+    static createTimeoutObservable(title, timeoutMillis) {
+        return rxjs_1.Observable.create((observer) => {
+            const id = setTimeout(() => {
+                clearTimeout(id);
+                observer.next(new ratchet_common_1.TimeoutToken(title, timeoutMillis));
+            }, timeoutMillis);
+        });
+    }
+}
+exports.ObservableRatchet = ObservableRatchet;

package/dist/cjs/rxjs/rxjs-ratchet.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RxjsRatchet = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class RxjsRatchet {
+    static safeUnsubscribe(sub) {
+        return ratchet_common_1.MapRatchet.safeCallFunction(sub, 'unsubscribe');
+    }
+    static async waitForNonNullOnSubject(subject) {
+        if (!!subject.value) {
+            return subject.value;
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const innerSub = subject.subscribe((val) => {
+                    if (!!val) {
+                        RxjsRatchet.safeUnsubscribe(innerSub);
+                        resolve(val);
+                    }
+                });
+            });
+        }
+    }
+    static async waitForTargetValueOnSubject(subject, targetValue) {
+        if (subject.value === targetValue) {
+            return subject.value;
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const innerSub = subject.subscribe((val) => {
+                    if (val === targetValue) {
+                        RxjsRatchet.safeUnsubscribe(innerSub);
+                        resolve(val);
+                    }
+                });
+            });
+        }
+    }
+}
+exports.RxjsRatchet = RxjsRatchet;

package/dist/es/build/ratchet-misc-info.js

@@ -0,0 +1,14 @@
+export class RatchetMiscInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}

package/dist/es/handlebars/handlebars-ratchet.js

@@ -0,0 +1,110 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { NumberRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common';
+export class HandlebarsRatchet {
+    constructor() { }
+    static functionMap() {
+        return {
+            eq: HandlebarsRatchet.equal,
+            ne: HandlebarsRatchet.notEqual,
+            lt: HandlebarsRatchet.lessThan,
+            gt: HandlebarsRatchet.greaterThan,
+            lte: HandlebarsRatchet.lessThanEqual,
+            gte: HandlebarsRatchet.greaterThanEqual,
+            and: HandlebarsRatchet.and,
+            or: HandlebarsRatchet.or,
+            formatBytes: HandlebarsRatchet.formatBytes,
+            rpn: HandlebarsRatchet.reversePolishNotation,
+            add: HandlebarsRatchet.add,
+            sub: HandlebarsRatchet.sub,
+            mul: HandlebarsRatchet.mul,
+            div: HandlebarsRatchet.div,
+            mod: HandlebarsRatchet.mod,
+            maxNum: HandlebarsRatchet.maxNum,
+            minNum: HandlebarsRatchet.minNum,
+        };
+    }
+    static registerAll(handlebars) {
+        handlebars.registerHelper(HandlebarsRatchet.functionMap());
+    }
+    static add(v1, v2) {
+        return NumberRatchet.safeNumber(v1) + NumberRatchet.safeNumber(v2);
+    }
+    static sub(v1, v2) {
+        return NumberRatchet.safeNumber(v1) - NumberRatchet.safeNumber(v2);
+    }
+    static mul(v1, v2) {
+        return NumberRatchet.safeNumber(v1) * NumberRatchet.safeNumber(v2);
+    }
+    static div(v1, v2) {
+        return NumberRatchet.safeNumber(v1) / NumberRatchet.safeNumber(v2);
+    }
+    static mod(v1, v2) {
+        return NumberRatchet.safeNumber(v1) % NumberRatchet.safeNumber(v2);
+    }
+    static equal(v1, v2) {
+        return v1 === v2;
+    }
+    static notEqual(v1, v2) {
+        return v1 !== v2;
+    }
+    static lessThan(v1, v2) {
+        return v1 < v2;
+    }
+    static lessThanEqual(v1, v2) {
+        return v1 <= v2;
+    }
+    static greaterThan(v1, v2) {
+        return v1 > v2;
+    }
+    static greaterThanEqual(v1, v2) {
+        return v1 >= v2;
+    }
+    static maxNum(...args) {
+        return Math.max(...args.slice(0, -1));
+    }
+    static minNum(...args) {
+        return Math.min(...args.slice(0, -1));
+    }
+    static and(...args) {
+        return Array.prototype.every.call(args, Boolean);
+    }
+    static or(...args) {
+        return Array.prototype.slice.call(args, 0, -1).some(Boolean);
+    }
+    static formatBytes(v1) {
+        return StringRatchet.formatBytes(v1);
+    }
+    static reversePolishNotation(...args) {
+        let rval = null;
+        try {
+            const fns = Object.assign({}, HandlebarsRatchet.functionMap());
+            delete fns['formatBytes'];
+            const stack = [];
+            for (let i = 0; i < args.length - 1; i++) {
+                const a = args[i];
+                if (fns[a]) {
+                    if (stack.length > 1) {
+                        const op2 = stack.pop();
+                        const op1 = stack.pop();
+                        const res = fns[a](op1, op2, {});
+                        stack.push(res);
+                    }
+                    else {
+                        ErrorRatchet.throwFormattedErr('Cannot execute operation %s - not enough args', a);
+                    }
+                }
+                else {
+                    stack.push(a);
+                }
+            }
+            rval = stack.pop();
+        }
+        catch (err) {
+            Logger.error('Failed to execute RPN: %s', err, err);
+            rval = ErrorRatchet.asErr(err)?.message || 'Failure';
+        }
+        return rval;
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,5 @@
+export * from './build/ratchet-misc-info';
+export * from './handlebars/handlebars-ratchet';
+export * from './model-validator/model-validator';
+export * from './rxjs/observable-ratchet';
+export * from './rxjs/rxjs-ratchet';

package/dist/es/model-validator/model-validator.js

@@ -0,0 +1,50 @@
+import Validator from 'swagger-model-validator';
+import yaml from 'js-yaml';
+import { ErrorRatchet, Logger, MapRatchet } from '@bitblit/ratchet-common';
+export class ModelValidator {
+    constructor(allModels) {
+        this.allModels = allModels;
+        if (!allModels || Object.keys(allModels).length == 0) {
+            ErrorRatchet.throwFormattedErr('Cannot create model validator, passed models was null/empty : %j', allModels);
+        }
+    }
+    static createFromYamlString(yamlString, rootPath) {
+        const src = yaml.load(yamlString);
+        const modelSrc = rootPath && rootPath.length > 0 ? MapRatchet.findValue(src, rootPath) : src;
+        return ModelValidator.createFromParsedObject(modelSrc);
+    }
+    static createFromParsedObject(parsedObject) {
+        return new ModelValidator(parsedObject);
+    }
+    get modelNames() {
+        return Object.keys(this.allModels);
+    }
+    addModel(modelName, model) {
+        this.allModels[modelName] = model;
+    }
+    fetchModel(modelName) {
+        return this.allModels[modelName];
+    }
+    validate(modelName, modelObject, emptyAllowed = false, extraPropertiesAllowed = true) {
+        let rval = [];
+        Logger.silly('Validating model %s all definitions are : %j', modelName, this.allModels);
+        const modelEmpty = !modelObject || Object.keys(modelObject).length === 0;
+        if (modelEmpty) {
+            if (!emptyAllowed) {
+                rval.push('Empty / null object sent, but empty not allowed here');
+            }
+        }
+        else {
+            if (this.allModels && modelName && this.allModels[modelName]) {
+                const validation = new Validator().validate(modelObject, this.allModels[modelName], this.allModels, emptyAllowed, extraPropertiesAllowed);
+                if (validation.errorCount > 0) {
+                    rval = validation.errors.map((e) => e.message);
+                }
+            }
+            else {
+                rval = ['Model named "' + modelName + '" not present in schema'];
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/rxjs/observable-ratchet.js

@@ -0,0 +1,16 @@
+import { Observable, race } from 'rxjs';
+import { TimeoutToken } from '@bitblit/ratchet-common';
+export class ObservableRatchet {
+    static timeout(srcObservable, title, timeoutMillis) {
+        const rval = race(srcObservable, this.createTimeoutObservable(title, timeoutMillis));
+        return rval;
+    }
+    static createTimeoutObservable(title, timeoutMillis) {
+        return Observable.create((observer) => {
+            const id = setTimeout(() => {
+                clearTimeout(id);
+                observer.next(new TimeoutToken(title, timeoutMillis));
+            }, timeoutMillis);
+        });
+    }
+}

package/dist/es/rxjs/rxjs-ratchet.js

@@ -0,0 +1,36 @@
+import { MapRatchet } from '@bitblit/ratchet-common';
+export class RxjsRatchet {
+    static safeUnsubscribe(sub) {
+        return MapRatchet.safeCallFunction(sub, 'unsubscribe');
+    }
+    static async waitForNonNullOnSubject(subject) {
+        if (!!subject.value) {
+            return subject.value;
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const innerSub = subject.subscribe((val) => {
+                    if (!!val) {
+                        RxjsRatchet.safeUnsubscribe(innerSub);
+                        resolve(val);
+                    }
+                });
+            });
+        }
+    }
+    static async waitForTargetValueOnSubject(subject, targetValue) {
+        if (subject.value === targetValue) {
+            return subject.value;
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const innerSub = subject.subscribe((val) => {
+                    if (val === targetValue) {
+                        RxjsRatchet.safeUnsubscribe(innerSub);
+                        resolve(val);
+                    }
+                });
+            });
+        }
+    }
+}