@bitblit/ratchet-misc 4.0.115-alpha → 4.0.119-alpha

package/lib/rxjs/observable-ratchet.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
+import { TimeoutToken } from '@bitblit/ratchet-common';
 export declare class ObservableRatchet {
     static timeout<T>(srcObservable: Observable<T | TimeoutToken>, title: string, timeoutMillis: number): Observable<T | TimeoutToken>;
     static createTimeoutObservable<T>(title: string, timeoutMillis: number): Observable<T | TimeoutToken>;

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@bitblit/ratchet-misc",
-  "version": "4.0.115-alpha",
+  "version": "4.0.119-alpha",
   "description": "Ratchet miscellaneous tooling that requires smallish dependant libraries",
   "sideEffects": false,
   "type": "module",
-  "module": "index.js",
   "files": [
     "lib/*",
     "bin/*"
   ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs"
+    }
+  },
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
     "William Weiss <npm@codification.org>",
@@ -35,9 +40,8 @@
     "docs": "typedoc",
     "lint": "eslint src/**/*.ts",
     "lint-fix": "eslint --fix src/**/*.ts",
-    "__generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
-    "__build": "yarn run generate-barrels && tsc",
-    "build": "tsc",
+    "generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts && sed -i 's/\\x27;/.js\\x27;/' src/index.ts",
+    "build": "yarn clean && yarn generate-barrels && rollup -c rollup.config.js",
     "force-build": "tsc --build --force"
   },
   "repository": {
@@ -64,11 +68,6 @@
     "swagger-model-validator": "3.0.21"
   },
   "peerDependencies": {
-    "handlebars": "^4.7.7",
-    "handlebars-layouts": "^3.1.4",
-    "js-yaml": "^4.1.0",
-    "rxjs": "^7.8.1",
-    "swagger-model-validator": "^3.0.21"
   },
   "resolutions": {},
   "devDependencies": {}

package/lib/build/ratchet-misc-info.js

@@ -1,14 +0,0 @@
-export class RatchetMiscInfo {
-    constructor() { }
-    static buildInformation() {
-        const val = {
-            version: 'LOCAL-SNAPSHOT',
-            hash: 'LOCAL-HASH',
-            branch: 'LOCAL-BRANCH',
-            tag: 'LOCAL-TAG',
-            timeBuiltISO: 'LOCAL-TIME-ISO',
-            notes: 'LOCAL-NOTES',
-        };
-        return val;
-    }
-}

package/lib/handlebars/handlebars-ratchet.js

@@ -1,110 +0,0 @@
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-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/lib/handlebars/handlebars-ratchet.spec.js

@@ -1,107 +0,0 @@
-import handlebars from 'handlebars';
-import { HandlebarsRatchet } from './handlebars-ratchet.js';
-describe('#handlebarsService', () => {
-    it('should test equal', async () => {
-        handlebars.registerHelper('eq', HandlebarsRatchet.equal);
-        const out1 = handlebars.compile('{{eq 1 2}}')({});
-        expect(out1).toEqual('false');
-        const out2 = handlebars.compile('{{eq 1 1}}')({});
-        expect(out2).toEqual('true');
-        const out3 = handlebars.compile('{{eq 1 a}}')({ a: 1 });
-        expect(out3).toEqual('true');
-    });
-    it('should test notequal', async () => {
-        handlebars.registerHelper('ne', HandlebarsRatchet.notEqual);
-        const out1 = handlebars.compile('{{ne 1 2}}')({});
-        expect(out1).toEqual('true');
-        const out2 = handlebars.compile('{{ne 1 1}}')({});
-        expect(out2).toEqual('false');
-        const out3 = handlebars.compile('{{ne 1 a}}')({ a: 1 });
-        expect(out3).toEqual('false');
-    });
-    it('should test less-than/less-than-equal', async () => {
-        handlebars.registerHelper('lt', HandlebarsRatchet.lessThan);
-        handlebars.registerHelper('lte', HandlebarsRatchet.lessThanEqual);
-        const out1 = handlebars.compile('{{lt 1 2}}')({});
-        expect(out1).toEqual('true');
-        const out2 = handlebars.compile('{{lt 1 1}}')({});
-        expect(out2).toEqual('false');
-        const out3 = handlebars.compile('{{lte 1 1}}')({});
-        expect(out3).toEqual('true');
-        const out4 = handlebars.compile('{{lt 20 1}}')({});
-        expect(out4).toEqual('false');
-    });
-    it('should test greater-than/greater-than-equal', async () => {
-        handlebars.registerHelper('gt', HandlebarsRatchet.greaterThan);
-        handlebars.registerHelper('gte', HandlebarsRatchet.greaterThanEqual);
-        const out1 = handlebars.compile('{{gt 2 1}}')({});
-        expect(out1).toEqual('true');
-        const out2 = handlebars.compile('{{gt 1 1}}')({});
-        expect(out2).toEqual('false');
-        const out3 = handlebars.compile('{{gte 1 1}}')({});
-        expect(out3).toEqual('true');
-        const out4 = handlebars.compile('{{gt 1 20}}')({});
-        expect(out4).toEqual('false');
-    });
-    it('should test and/or', async () => {
-        handlebars.registerHelper('and', HandlebarsRatchet.and);
-        handlebars.registerHelper('or', HandlebarsRatchet.or);
-        const out1 = handlebars.compile('{{and true true}}')({});
-        expect(out1).toEqual('true');
-        const out2 = handlebars.compile('{{and true false}}')({});
-        expect(out2).toEqual('false');
-        const out3 = handlebars.compile('{{and false false}}')({});
-        expect(out3).toEqual('false');
-        const out4 = handlebars.compile('{{or true true}}')({});
-        expect(out4).toEqual('true');
-        const out5 = handlebars.compile('{{or true false}}')({});
-        expect(out5).toEqual('true');
-        const out6 = handlebars.compile('{{or false false}}')({});
-        expect(out6).toEqual('false');
-        const out7 = handlebars.compile('{{and true true true true}}')({});
-        expect(out7).toEqual('true');
-        const out8 = handlebars.compile('{{or true false true false}}')({});
-        expect(out8).toEqual('true');
-    });
-    it('should test formatBytes', async () => {
-        handlebars.registerHelper('formatBytes', HandlebarsRatchet.formatBytes);
-        const out1 = handlebars.compile('{{formatBytes 10}}')({});
-        expect(out1).toEqual('10 Bytes');
-        const out2 = handlebars.compile('{{formatBytes 1040}}')({});
-        expect(out2).toEqual('1.02 KB');
-        const out3 = handlebars.compile('{{formatBytes 2100000}}')({});
-        expect(out3).toEqual('2 MB');
-        const out4 = handlebars.compile('{{formatBytes 3300000000}}')({});
-        expect(out4).toEqual('3.07 GB');
-    });
-    it('should test mat', async () => {
-        HandlebarsRatchet.registerAll(handlebars);
-        const add = handlebars.compile('{{add 2 1}}')({});
-        expect(add).toEqual('3');
-        const sub1 = handlebars.compile('{{sub 1 2}}')({});
-        expect(sub1).toEqual('-1');
-        const sub2 = handlebars.compile('{{sub 2 1}}')({});
-        expect(sub2).toEqual('1');
-        const mul = handlebars.compile('{{mul 2 3}}')({});
-        expect(mul).toEqual('6');
-        const div1 = handlebars.compile('{{div 2 1}}')({});
-        expect(div1).toEqual('2');
-        const div2 = handlebars.compile('{{div 1 2}}')({});
-        expect(div2).toEqual('0.5');
-        const mod = handlebars.compile('{{mod 3 2}}')({});
-        expect(mod).toEqual('1');
-        const maxNum = handlebars.compile('{{maxNum 2 1 8 5 7}}')({});
-        expect(maxNum).toEqual('8');
-        const minNum = handlebars.compile('{{minNum 2 1 8 5 7}}')({});
-        expect(minNum).toEqual('1');
-    });
-    it('should test rpn', async () => {
-        handlebars.registerHelper('rpn', HandlebarsRatchet.reversePolishNotation);
-        const out1 = handlebars.compile('{{rpn 5 10 "maxNum" 10 "add" 3 "sub"}}')({});
-        expect(out1).toEqual('17');
-        const out2 = handlebars.compile('{{rpn n1 n2 "div" n3 "mul" 6 "mod"}}')({ n1: 10, n2: 5, n3: '10' });
-        expect(out2).toEqual('2');
-        const out3 = handlebars.compile('{{rpn 1 "div"}}')({});
-        expect(out3).toEqual('Cannot execute operation div - not enough args');
-    });
-});

package/lib/index.js

@@ -1 +0,0 @@
-export {};

package/lib/model-validator/model-validator.js

@@ -1,53 +0,0 @@
-import Validator from 'swagger-model-validator';
-import yaml from 'js-yaml';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
-export class ModelValidator {
-    allModels;
-    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/lib/model-validator/model-validator.spec.js

@@ -1,34 +0,0 @@
-import { ModelValidator } from './model-validator.js';
-import fs from 'fs';
-import path from 'path';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { EsmRatchet } from '@bitblit/ratchet-common/lib/lang/esm-ratchet.js';
-describe('#modelValidator', function () {
-    it('should list an error', function () {
-        const yamlString = fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/sample-objects.spec.yaml'))
-            .toString();
-        const validator = ModelValidator.createFromYamlString(yamlString, ['ModelObjects']);
-        const shouldPass = {
-            numberField: 7,
-            stringField: 'xxx',
-        };
-        const shouldFail = {
-            numberField: 70,
-            stringField: 'xxx',
-        };
-        const errShouldPass = validator.validate('SimpleItem', shouldPass, false, true);
-        const errShouldFail = validator.validate('SimpleItem', shouldFail, false, true);
-        Logger.silly('shouldPass: %j', errShouldPass);
-        Logger.silly('shouldFail: %j', errShouldFail);
-        expect(errShouldPass).toBeTruthy();
-        expect(errShouldPass.length).toEqual(0);
-        expect(errShouldFail).toBeTruthy();
-        expect(errShouldFail.length).toEqual(1);
-        const modelNames = validator.modelNames;
-        expect(modelNames.length).toEqual(2);
-        expect(modelNames.includes('SimpleItem')).toBeTruthy();
-        expect(modelNames.includes('ApiErrorResponse')).toBeTruthy();
-        expect(modelNames.includes('XYZ')).toBeFalsy();
-    });
-});

package/lib/rxjs/observable-ratchet.js

@@ -1,16 +0,0 @@
-import { Observable, race } from 'rxjs';
-import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
-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/lib/rxjs/observable-ratchet.spec.js

@@ -1,18 +0,0 @@
-import { timer } from 'rxjs';
-import { ObservableRatchet } from './observable-ratchet.js';
-import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
-describe('#timeout', function () {
-    it('should correctly return before timeout', function () {
-        const src = timer(1000);
-        const timeoutOb = ObservableRatchet.timeout(src, '1000ms interval', 1500);
-        timeoutOb.subscribe((result) => expect(result).toEqual(0));
-    });
-    it('should correctly returns null after timeout', function () {
-        const src = timer(1500);
-        const timeoutOb = ObservableRatchet.timeout(src, '1500ms interval', 1000);
-        timeoutOb.subscribe((result) => {
-            expect(result).toBeTruthy();
-            expect(result instanceof TimeoutToken).toBeTruthy();
-        });
-    });
-});

package/lib/rxjs/rxjs-ratchet.js

@@ -1,36 +0,0 @@
-import { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
-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);
-                    }
-                });
-            });
-        }
-    }
-}

package/lib/rxjs/rxjs-ratchet.spec.js

@@ -1,16 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { RxjsRatchet } from './rxjs-ratchet.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-describe('#waitForNonNullOnSubject', function () {
-    it('should resolve after 1 second', async () => {
-        const sub = new BehaviorSubject(null);
-        const testFn = PromiseRatchet.wait(1000).then((r) => {
-            sub.next(5);
-        });
-        Logger.info('Waiting for non-null');
-        const result = await RxjsRatchet.waitForNonNullOnSubject(sub);
-        Logger.info('Got %d', result);
-        expect(result).toEqual(5);
-    }, 10000);
-});