@bitblit/ratchet-common 4.0.99-alpha → 4.0.103-alpha

package/lib/stream/string-writable.spec.js

@@ -0,0 +1,12 @@
+import { StringWritable } from './string-writable.js';
+describe('#StringWritable', function () {
+    it('should write cumulatively to a string', async () => {
+        const sr = new StringWritable();
+        const callback = () => {
+        };
+        sr._write('a', null, callback);
+        sr._write('b', null, callback);
+        sr._write('c', null, callback);
+        expect(sr.value.length).toEqual(3);
+    });
+});

package/{dist/es → lib}/third-party/google/google-recaptcha-ratchet.js

@@ -1,7 +1,8 @@
-import { Logger } from '../../logger/logger';
-import { StringRatchet } from '../../lang/string-ratchet';
+import { Logger } from '../../logger/logger.js';
+import { StringRatchet } from '../../lang/string-ratchet.js';
 import fetch from 'cross-fetch';
 export class GoogleRecaptchaRatchet {
+    static GOOGLE_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify?secret={{KEY}}&response={{TOKEN}}';
     static async verifyRecaptchaToken(keySecret, token, fetchFn = fetch) {
         Logger.debug('Verifying recaptcha token : %s', token);
         let rval = null;
@@ -25,4 +26,3 @@ export class GoogleRecaptchaRatchet {
         return rval;
     }
 }
-GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify?secret={{KEY}}&response={{TOKEN}}';

package/lib/third-party/google/google-recaptcha-ratchet.spec.d.ts

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

package/lib/third-party/google/google-recaptcha-ratchet.spec.js

@@ -0,0 +1,20 @@
+import { GoogleRecaptchaRatchet } from './google-recaptcha-ratchet.js';
+import { jest } from '@jest/globals';
+const fakeFetch = jest.fn((input, init) => Promise.resolve({
+    json: () => Promise.resolve({ success: true }),
+}));
+const fakeFailFetch = jest.fn((input, init) => Promise.reject('Failed to read'));
+describe('#googleRecaptchaService', () => {
+    it('should validate a recaptcha token', async () => {
+        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFetch);
+        expect(res).toBeTruthy();
+    });
+    it('should fail with no token', async () => {
+        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', null, fakeFetch);
+        expect(res).toBeFalsy();
+    });
+    it('should fail if http fails', async () => {
+        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFailFetch);
+        expect(res).toBeFalsy();
+    });
+});

package/{dist/types → lib}/third-party/twilio/twilio-ratchet.d.ts

@@ -1,7 +1,3 @@
-/**
- * This class is for people who just need to send an occasionaly outbound text message and don't need
- * Twilio's 7mb non-tree-shakable library
- */
 export declare class TwilioRatchet {
     private accountSid;
     private authToken;

package/{dist/es → lib}/third-party/twilio/twilio-ratchet.js

@@ -1,9 +1,13 @@
 import fetch from 'cross-fetch';
-import { RequireRatchet } from '../../lang/require-ratchet';
-import { Base64Ratchet } from '../../lang/base64-ratchet';
-import { StringRatchet } from '../../lang/string-ratchet';
-import { Logger } from '../../logger/logger';
+import { RequireRatchet } from '../../lang/require-ratchet.js';
+import { Base64Ratchet } from '../../lang/base64-ratchet.js';
+import { StringRatchet } from '../../lang/string-ratchet.js';
+import { Logger } from '../../logger/logger.js';
 export class TwilioRatchet {
+    accountSid;
+    authToken;
+    outBoundNumber;
+    static TWILLIO_BASE_API_URL = 'https://api.twilio.com/2010-04-01';
     constructor(accountSid, authToken, outBoundNumber) {
         this.accountSid = accountSid;
         this.authToken = authToken;
@@ -67,4 +71,3 @@ export class TwilioRatchet {
         return /^\+?[1-9]\d{1,14}$/.test(num);
     }
 }
-TwilioRatchet.TWILLIO_BASE_API_URL = 'https://api.twilio.com/2010-04-01';

package/{dist/types → lib}/transform/built-in-transforms.d.ts

@@ -1,4 +1,4 @@
-import { TransformRule } from './transform-rule';
+import { TransformRule } from './transform-rule.js';
 export declare class BuiltInTransforms {
     static keysOnly(rule: TransformRule): TransformRule;
     static valuesOnly(rule: TransformRule): TransformRule;

package/{dist/es → lib}/transform/built-in-transforms.js

@@ -1,5 +1,5 @@
-import { Logger } from '../logger/logger';
-import { NumberRatchet } from '../lang/number-ratchet';
+import { Logger } from '../logger/logger.js';
+import { NumberRatchet } from '../lang/number-ratchet.js';
 import { DateTime } from 'luxon';
 export class BuiltInTransforms {
     static keysOnly(rule) {

package/lib/transform/transform-rule.js

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

package/{dist/types → lib}/tx/transaction-configuration.d.ts

@@ -1,5 +1,5 @@
-import { TransactionResult } from './transaction-result';
-import { LoggerLevelName } from '../logger/logger-level-name';
+import { TransactionResult } from './transaction-result.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export interface TransactionConfiguration<T> {
     stepLogLevel?: LoggerLevelName;
     executeAfterRollback?(result: TransactionResult<T>): Promise<void>;

package/lib/tx/transaction-configuration.js

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

package/{dist/types → lib}/tx/transaction-ratchet.d.ts

@@ -1,6 +1,6 @@
-import { TransactionStep } from './transaction-step';
-import { TransactionResult } from './transaction-result';
-import { TransactionConfiguration } from './transaction-configuration';
+import { TransactionStep } from './transaction-step.js';
+import { TransactionResult } from './transaction-result.js';
+import { TransactionConfiguration } from './transaction-configuration.js';
 export declare class TransactionRatchet {
     static execute<T>(steps: TransactionStep<T>[], initialContext: T, inConfiguration?: TransactionConfiguration<T>): Promise<TransactionResult<T>>;
 }

package/{dist/es → lib}/tx/transaction-ratchet.js

@@ -1,7 +1,7 @@
-import { Logger } from '../logger/logger';
-import { RequireRatchet } from '../lang/require-ratchet';
-import { LoggerLevelName } from '../logger/logger-level-name';
-import { TransactionFinalState } from './transaction-final-state';
+import { Logger } from '../logger/logger.js';
+import { RequireRatchet } from '../lang/require-ratchet.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { TransactionFinalState } from './transaction-final-state.js';
 export class TransactionRatchet {
     static async execute(steps, initialContext, inConfiguration) {
         RequireRatchet.notNullOrUndefined(steps, 'steps');

package/lib/tx/transaction-ratchet.spec.d.ts

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

package/lib/tx/transaction-ratchet.spec.js

@@ -0,0 +1,130 @@
+import { TransactionRatchet } from './transaction-ratchet.js';
+import { TransactionFinalState } from './transaction-final-state.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+class TestTransactionStep {
+    async execute(context, stepNumber) {
+        context.runningTotal += stepNumber;
+        if (stepNumber === context?.failStep) {
+            throw new Error('Forced error at step ' + stepNumber);
+        }
+    }
+    async rollback(context, stepNumber) {
+        context.runningTotal -= stepNumber;
+        if (stepNumber === context?.failRollbackStep) {
+            throw new Error('Forced rollback error at step ' + stepNumber);
+        }
+    }
+}
+describe('#TransactionRatchet.execute', function () {
+    it('should return the right value when it executes successfully', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0 };
+        const result = await TransactionRatchet.execute(steps, ctx);
+        expect(result).not.toBeNull();
+        expect(result.error).toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.Success);
+        expect(result.finalContext.runningTotal).toEqual(3);
+    });
+    it('should return the right value when it rolls back successfully fail step 2', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2 };
+        const result = await TransactionRatchet.execute(steps, ctx);
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.runningTotal).toEqual(0);
+    });
+    it('should return the right value when it rolls back successfully fail step 1', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2 };
+        const result = await TransactionRatchet.execute(steps, ctx);
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.runningTotal).toEqual(0);
+    });
+    it('should return the right value the rollback fails', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+        const result = await TransactionRatchet.execute(steps, ctx);
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+        expect(result.finalContext.runningTotal).toEqual(0);
+        expect(result.errorStep).toEqual(2);
+        expect(result.rollbackErrorStep).toEqual(1);
+        expect(result.error).not.toBeUndefined();
+        expect(result.rollbackError).not.toBeUndefined();
+    });
+    it('should run the post-error handler when a failure happens', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2 };
+        const result = await TransactionRatchet.execute(steps, ctx, {
+            executeAfterRollback: async (res) => {
+                res.finalContext.postTxTracker = 1;
+            },
+        });
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.postTxTracker).toEqual(1);
+    });
+    it('should run both post-error handler when a failure happens in both error and rollback', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+        const result = await TransactionRatchet.execute(steps, ctx, {
+            executeAfterRollback: async (res) => {
+                res.finalContext.postTxTracker = 1;
+            },
+            executeAfterRollbackFailure: async (res) => {
+                res.finalContext.postTxTracker += 1;
+            },
+        });
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.postTxTracker).toEqual(2);
+    });
+    it('should still return if a post-tx executor fails', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+        const result = await TransactionRatchet.execute(steps, ctx, {
+            executeAfterRollback: async (res) => {
+                res.finalContext.postTxTracker = 1;
+            },
+            executeAfterRollbackFailure: async (res) => {
+                res.finalContext.postTxTracker += 1;
+                throw new Error('Forced tracker failure');
+            },
+        });
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.postTxTracker).toEqual(2);
+    });
+    it('should work with transaction configuration that only provides read log level access', async () => {
+        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+        const result = await TransactionRatchet.execute(steps, ctx, {
+            get stepLogLevel() {
+                return LoggerLevelName.info;
+            },
+            executeAfterRollback: async (res) => {
+                res.finalContext.postTxTracker = 1;
+            },
+            executeAfterRollbackFailure: async (res) => {
+                res.finalContext.postTxTracker += 1;
+                throw new Error('Forced tracker failure');
+            },
+        });
+        expect(result).not.toBeUndefined();
+        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+        expect(result.errorStep).toEqual(2);
+        expect(result.error).not.toBeUndefined();
+        expect(result.finalContext.postTxTracker).toEqual(2);
+    });
+});

package/{dist/types → lib}/tx/transaction-result.d.ts

@@ -1,4 +1,4 @@
-import { TransactionFinalState } from './transaction-final-state';
+import { TransactionFinalState } from './transaction-final-state.js';
 export interface TransactionResult<T> {
     finalContext: T;
     finalState: TransactionFinalState;

package/lib/tx/transaction-result.js

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

package/lib/tx/transaction-step.js

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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@bitblit/ratchet-common",
-  "version": "4.0.99-alpha",
+  "version": "4.0.103-alpha",
   "description": "Common tools for general use",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "module": "index.js",
   "files": [
-    "dist/*"
+    "lib/*",
+    "bin/*"
   ],
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
@@ -29,16 +29,15 @@
   "config": {},
   "scripts": {
     "watch": "tsc-watch",
-    "clean": "shx rm -Rf dist",
-    "test": "jest",
+    "clean": "shx rm -Rf lib",
+    "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",

package/dist/cjs/2d/line-2d.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/plane-2d.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/point-2d.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/poly-line-2d.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/ratchet-2d.js

@@ -1,250 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ratchet2d = void 0;
-const boolean_ratchet_1 = require("../lang/boolean-ratchet");
-class Ratchet2d {
-    constructor() { }
-    static translateToOriginVector(points) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points)) {
-            rval = {
-                x: null,
-                y: null,
-            };
-            points.forEach((p) => {
-                rval.x = rval.x === null || p.x < rval.x ? p.x : rval.x;
-                rval.y = rval.y === null || p.y < rval.y ? p.y : rval.y;
-            });
-            rval.x *= -1;
-            rval.y *= -1;
-        }
-        return rval;
-    }
-    static minimalContainingPlane(points) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points)) {
-            rval = {
-                width: 0,
-                height: 0,
-            };
-            points.forEach((p) => {
-                rval.width = Math.max(rval.width, p.x + 1);
-                rval.height = Math.max(rval.height, p.y + 1);
-            });
-        }
-        return rval;
-    }
-    static scaleVector(src, dst) {
-        let rval = null;
-        if (Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
-            rval = {
-                x: dst.width / src.width,
-                y: dst.height / src.height,
-            };
-        }
-        return rval;
-    }
-    static samePoint(p1, p2) {
-        return !!p1 && !!p2 && p1.x === p2.x && p1.y === p2.y;
-    }
-    static atLeastOneDimensionShared(p1, p2) {
-        return !!p1 && !!p2 && (p1.x === p2.x || p1.y === p2.y);
-    }
-    static validPlane(plane) {
-        return !!plane && !!plane.height && !!plane.width;
-    }
-    static validLine(line) {
-        return !!line && Ratchet2d.validPoint(line.p1) && Ratchet2d.validPoint(line.p2) && !Ratchet2d.samePoint(line.p1, line.p2);
-    }
-    static validLines(lines) {
-        return !!lines && boolean_ratchet_1.BooleanRatchet.allTrue(lines.map((l) => Ratchet2d.validLine(l)));
-    }
-    static validPolyLine(pline) {
-        var _a;
-        return !!pline && ((_a = pline.pts) === null || _a === void 0 ? void 0 : _a.length) > 1 && boolean_ratchet_1.BooleanRatchet.allTrue(pline.pts.map((p) => Ratchet2d.validPoint(p)));
-    }
-    static polyLineToLines(pline) {
-        let rval = null;
-        if (Ratchet2d.validPolyLine(pline)) {
-            rval = [];
-            for (let i = 1; i < pline.pts.length; i++) {
-                rval.push({ p1: pline.pts[i - 1], p2: pline.pts[i] });
-            }
-        }
-        return rval;
-    }
-    static lastPointOnPolyLine(polyLine) {
-        return Ratchet2d.validPolyLine(polyLine) ? polyLine.pts[polyLine.pts.length - 1] : null;
-    }
-    static lineToPolyLine(line) {
-        return Ratchet2d.validLine(line) ? { pts: [line.p1, line.p2] } : null;
-    }
-    static linesToPolyLines(lines) {
-        let rval = null;
-        if (Ratchet2d.validLines(lines)) {
-            rval = [];
-            let currentPLine = Ratchet2d.lineToPolyLine(lines[0]);
-            for (let i = 1; i < lines.length; i++) {
-                if (Ratchet2d.samePoint(Ratchet2d.lastPointOnPolyLine(currentPLine), lines[i].p1)) {
-                    currentPLine.pts.push(lines[i].p2);
-                }
-                else {
-                    rval.push(currentPLine);
-                    currentPLine = Ratchet2d.lineToPolyLine(lines[i]);
-                }
-            }
-            rval.push(currentPLine);
-        }
-        return rval;
-    }
-    static validPoint(pt) {
-        return !!pt && pt.x != null && pt.x != undefined && pt.y !== null && pt.y !== undefined;
-    }
-    static validPoints(pt) {
-        return (!!pt &&
-            boolean_ratchet_1.BooleanRatchet.allTrue(pt.map((p) => Ratchet2d.validPoint(p)), false));
-    }
-    static planeContainsPoint(pt, plane) {
-        return Ratchet2d.validPlane(plane) && Ratchet2d.validPoint(pt) && pt.x >= 0 && pt.x < plane.width && pt.y >= 0 && pt.y < plane.height;
-    }
-    static planeContainsPoints(pt, plane) {
-        return pt && pt.map((p) => Ratchet2d.planeContainsPoint(p, plane)).reduce((a, i) => a && i, true);
-    }
-    static linesToPoints(lines) {
-        let rval = null;
-        if (Ratchet2d.validLines(lines)) {
-            rval = lines.map((l) => [l.p1, l.p2]).flat();
-        }
-        return rval;
-    }
-    static pointsToLines(points) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points)) {
-            if (points.length % 2 == 0) {
-                rval = [];
-                for (let i = 0; i < points.length; i += 2) {
-                    rval.push({ p1: points[i], p2: points[i + 1] });
-                }
-            }
-            else {
-                throw new Error('Cannot convert non-even array of points into lines');
-            }
-        }
-        return rval;
-    }
-    static rotateRightAboutOrigin90Degrees(points, times = 1) {
-        let rval = null;
-        let translate = { x: 0, y: 0 };
-        if (Ratchet2d.validPoints(points)) {
-            rval = Object.assign([], points);
-            translate = Ratchet2d.translateToOriginVector(rval);
-            rval = Ratchet2d.translate(rval, translate);
-            let plane = Ratchet2d.minimalContainingPlane(rval);
-            rval = Ratchet2d.xToY(rval);
-            plane = { width: plane.height, height: plane.width };
-            translate = { x: translate.y * -1, y: translate.x * -1 };
-            rval = Ratchet2d.mirrorPointsOnPlane(rval, plane, true, false);
-            rval = Ratchet2d.translate(rval, translate);
-        }
-        const timesToRotate = times > 4 ? times % 4 : times;
-        if (timesToRotate > 1) {
-            rval = Ratchet2d.rotateRightAboutOrigin90Degrees(rval, timesToRotate - 1);
-        }
-        return rval;
-    }
-    static planeContainsLines(lines, plane) {
-        return lines && Ratchet2d.planeContainsPoints(lines.map((l) => [l.p1, l.p2]).flat(), plane);
-    }
-    static planeContainsPolyLine(pline, plane) {
-        return Ratchet2d.planeContainsLines(Ratchet2d.polyLineToLines(pline), plane);
-    }
-    static planeContainsLine(line, plane) {
-        return (Ratchet2d.validPlane(plane) &&
-            Ratchet2d.validLine(line) &&
-            Ratchet2d.planeContainsPoint(line.p1, plane) &&
-            Ratchet2d.planeContainsPoint(line.p2, plane));
-    }
-    static xToY(points) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points)) {
-            rval = points.map((p) => {
-                const next = { x: p.y, y: p.x };
-                return next;
-            });
-        }
-        return rval;
-    }
-    static translate(points, xlate) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points) && Ratchet2d.validPoint(xlate)) {
-            rval = points.map((p) => {
-                const next = {
-                    x: p.x + xlate.x,
-                    y: p.y + xlate.y,
-                };
-                return next;
-            });
-        }
-        return rval;
-    }
-    static mirrorPointsOnPlane(points, src, mirrorX, mirrorY) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src)) {
-            if (mirrorX || mirrorY) {
-                rval = points.map((p) => {
-                    const next = {
-                        x: mirrorX ? src.width - 1 - p.x : p.x,
-                        y: mirrorY ? src.height - 1 - p.y : p.y,
-                    };
-                    return next;
-                });
-            }
-            else {
-                rval = Object.assign([], points);
-            }
-        }
-        return rval;
-    }
-    static transformPointsToNewPlane(points, src, dst) {
-        let rval = null;
-        if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
-            const scale = Ratchet2d.scaleVector(src, dst);
-            rval = points.map((p) => {
-                const next = { x: p.x * scale.x, y: p.y * scale.y };
-                return next;
-            });
-            rval = Ratchet2d.mirrorPointsOnPlane(rval, dst, dst.rightToLeft !== src.rightToLeft, dst.topToBottom !== src.topToBottom);
-        }
-        return rval;
-    }
-    static transformPointToNewPlane(point, src, dst) {
-        const tmp = Ratchet2d.transformPointsToNewPlane([point], src, dst);
-        return tmp.length === 1 ? tmp[0] : null;
-    }
-    static transformLines(lines, src, dst) {
-        return null;
-    }
-    static fitCurve(curveDef, inputX) {
-        curveDef.sort((a, b) => {
-            return a.x - b.x;
-        });
-        if (inputX <= curveDef[0].x) {
-            return curveDef[0].y;
-        }
-        else if (inputX >= curveDef[curveDef.length - 1].x) {
-            return curveDef[curveDef.length - 1].y;
-        }
-        else {
-            let idx = 0;
-            while (curveDef[idx + 1].x < inputX) {
-                idx++;
-            }
-            const xSpread = curveDef[idx + 1].x - curveDef[idx].x;
-            const ySpread = curveDef[idx + 1].y - curveDef[idx].y;
-            const pct = (inputX - curveDef[idx].x) / xSpread;
-            const yAdd = pct * ySpread;
-            return curveDef[idx].y + yAdd;
-        }
-    }
-}
-exports.Ratchet2d = Ratchet2d;

package/dist/cjs/build/build-information.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/cjs/histogram/histogram-entry.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });