@bitblit/ratchet-misc 4.0.99-alpha → 4.0.102-alpha

package/dist/{types/build → build}/ratchet-misc-info.d.ts

@@ -1,4 +1,4 @@
-import { BuildInformation } from '@bitblit/ratchet-common';
+import { BuildInformation } from '@bitblit/ratchet-common/dist/build/build-information.js';
 export declare class RatchetMiscInfo {
     private constructor();
     static buildInformation(): BuildInformation;

package/dist/{types/handlebars → handlebars}/handlebars-ratchet.d.ts

@@ -18,19 +18,5 @@ export declare class HandlebarsRatchet {
     static and(...args: any[]): boolean;
     static or(...args: any[]): boolean;
     static formatBytes(v1: number): string;
-    /**
-     * Soo... why have a implementation of reverse polish notation for Handlebars?  Well basically
-     * because handlebars does not support doing math internally, and sometimes I want to be able
-     * to do arbitrarily complex math inside my template, and even if I have functions like
-     * add and div, I cannot do things like this in templates (usually):
-     * add 5 (div 10 8)
-     * because handlebars typically will not do the parens correctly.  So, when you use RPN, there
-     * are no parenthesis, operation order is handled by the stack, so you can put pretty much anything
-     * you want in here
-     *
-     * And spare me any lectures about the evils of ANY logic in templates... if you send them my way, I'll assume you
-     * are someone who has spent your whole life working in a university system and never having to make a payroll
-     * @param args
-     */
     static reversePolishNotation(...args: any[]): string;
 }

package/dist/{es/handlebars → handlebars}/handlebars-ratchet.js

@@ -1,7 +1,7 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { NumberRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
-import { Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { NumberRatchet } from '@bitblit/ratchet-common/dist/lang/number-ratchet.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class HandlebarsRatchet {
     constructor() { }
     static functionMap() {

package/dist/handlebars/handlebars-ratchet.spec.d.ts

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

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

@@ -0,0 +1,107 @@
+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/dist/index.d.ts

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

package/dist/index.js

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

package/dist/{types/model-validator → model-validator}/model-validator.d.ts

@@ -1,6 +1,3 @@
-/**
- * Helper for validating endpoints
- */
 export declare class ModelValidator {
     private allModels;
     constructor(allModels: any);

package/dist/{es/model-validator → model-validator}/model-validator.js

@@ -1,7 +1,10 @@
 import Validator from 'swagger-model-validator';
 import yaml from 'js-yaml';
-import { ErrorRatchet, Logger, MapRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { MapRatchet } from '@bitblit/ratchet-common/dist/lang/map-ratchet.js';
 export class ModelValidator {
+    allModels;
     constructor(allModels) {
         this.allModels = allModels;
         if (!allModels || Object.keys(allModels).length == 0) {

package/dist/model-validator/model-validator.spec.d.ts

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

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

@@ -0,0 +1,34 @@
+import { ModelValidator } from './model-validator.js';
+import fs from 'fs';
+import path from 'path';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/dist/lang/esm-ratchet.js';
+describe('#modelValidator', function () {
+    it('should list an error', function () {
+        const yamlString = fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../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/dist/{types/rxjs → rxjs}/observable-ratchet.d.ts

@@ -1,10 +1,5 @@
 import { Observable } from 'rxjs';
-import { TimeoutToken } from '@bitblit/ratchet-common';
-/**
- * A class for simplifying working with rxjs observables.
- *
- * Contributed by William Weiss <npm@codification.org>
- */
+import { TimeoutToken } from '@bitblit/ratchet-common/dist/lang/timeout-token.js';
 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/dist/{es/rxjs → rxjs}/observable-ratchet.js

@@ -1,5 +1,5 @@
 import { Observable, race } from 'rxjs';
-import { TimeoutToken } from '@bitblit/ratchet-common';
+import { TimeoutToken } from '@bitblit/ratchet-common/dist/lang/timeout-token.js';
 export class ObservableRatchet {
     static timeout(srcObservable, title, timeoutMillis) {
         const rval = race(srcObservable, this.createTimeoutObservable(title, timeoutMillis));

package/dist/rxjs/observable-ratchet.spec.d.ts

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

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

@@ -0,0 +1,18 @@
+import { timer } from 'rxjs';
+import { ObservableRatchet } from './observable-ratchet.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/dist/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/dist/{es/rxjs → rxjs}/rxjs-ratchet.js

@@ -1,4 +1,4 @@
-import { MapRatchet } from '@bitblit/ratchet-common';
+import { MapRatchet } from '@bitblit/ratchet-common/dist/lang/map-ratchet.js';
 export class RxjsRatchet {
     static safeUnsubscribe(sub) {
         return MapRatchet.safeCallFunction(sub, 'unsubscribe');

package/dist/rxjs/rxjs-ratchet.spec.d.ts

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

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

@@ -0,0 +1,16 @@
+import { BehaviorSubject } from 'rxjs';
+import { RxjsRatchet } from './rxjs-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/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);
+});

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bitblit/ratchet-misc",
-  "version": "4.0.99-alpha",
+  "version": "4.0.102-alpha",
   "description": "Ratchet miscellaneous tooling that requires smallish dependant libraries",
   "sideEffects": false,
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "module": "index.js",
   "files": [
-    "dist/*"
+    "dist/*",
+    "includes/*"
   ],
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
@@ -31,15 +31,14 @@
   "scripts": {
     "watch": "tsc-watch",
     "clean": "shx rm -Rf dist",
-    "test": "jest",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
     "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 && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:es": "tsc -p tsconfig.es.json",
-    "build:types": "tsc -p tsconfig.types.json"
+    "__generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
+    "__build": "yarn run generate-barrels && tsc",
+    "build": "tsc",
+    "force-build": "tsc --build --force"
   },
   "repository": {
     "type": "git",
@@ -60,14 +59,16 @@
   "dependencies": {
     "handlebars": "4.7.7",
     "handlebars-layouts": "3.1.4",
+    "js-yaml": "4.1.0",
     "rxjs": "7.8.0",
     "swagger-model-validator": "3.0.21"
   },
   "peerDependencies": {
-    "handlebars": "4.7.7",
-    "handlebars-layouts": "3.1.4",
-    "rxjs": "7.8.0",
-    "swagger-model-validator": "3.0.21"
+    "handlebars": "^4.7.7",
+    "handlebars-layouts": "^3.1.4",
+    "js-yaml": "^4.1.0",
+    "rxjs": "^7.8.0",
+    "swagger-model-validator": "^3.0.21"
   },
   "resolutions": {},
   "devDependencies": {}

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

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RatchetMiscInfo = void 0;
-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;
-    }
-}
-exports.RatchetMiscInfo = RatchetMiscInfo;

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

@@ -1,115 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-"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

@@ -1,55 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-"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

@@ -1,40 +0,0 @@
-"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/index.js

@@ -1,5 +0,0 @@
-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';