move all checks into public

Author: g-harel

internal/animate/state.ts

@@ -1,7 +1,5 @@
 import {Point} from "../types";
 import {RenderCache, InternalKeyframe, renderFramesAt, transitionFrames, Keyframe} from "./frames";
-import {typeCheck, error} from "../errors";
-import {timingFunctions} from "./timing";
 
 interface CallbackKeyframe extends Keyframe {
     callback?: () => void;
@@ -42,18 +40,6 @@ export const statefulAnimationGenerator = <K extends CallbackKeyframe, T>(
     const transition = (...keyframes: K[]) => {
         // Make sure frame info is valid.
         for (let i = 0; i < keyframes.length; i++) {
-            typeCheck(`keyframes[${i}]`, keyframes[i], ["object"]);
-            const {delay, duration, timingFunction, callback} = keyframes[i];
-            typeCheck(`keyframes[${i}].delay`, delay, ["number", "undefined"]);
-            if (delay && delay < 0) error(`keyframes[${i}].delay is invalid "${delay}".`);
-            typeCheck(`keyframes[${i}].duration`, duration, ["number"]);
-            if (duration && duration < 0)
-                error(`keyframes[${i}].duration is invalid "${duration}".`);
-            typeCheck(`keyframes[${i}].timingFunction`, timingFunction, ["string", "undefined"]);
-            if (timingFunctions[timingFunction || "linear"] === undefined) {
-                error(`"keyframes[${i}].timingFunction" is not recognized "${timingFunction}".`);
-            }
-            typeCheck(`keyframes[${i}].callback`, callback, ["function", "undefined"]);
             checker(keyframes[i], i);
         }
 

internal/errors.ts

@@ -1,4 +1,4 @@
-export const error = (message: string) => {
+export const err = (message: string) => {
     throw `(blobs2) ${message}`;
 };
 
@@ -7,6 +7,6 @@ export const typeCheck = (name: string, val: any, expected: string[]) => {
     if (actual === "number" && isNaN(val)) actual = "NaN";
     if (actual === "object" && val === null) actual = "null";
     if (!expected.includes(actual)) {
-        error(`"${name}" should have type "${expected.join("|")}" but was "${actual}".`);
+        err(`"${name}" should have type "${expected.join("|")}" but was "${actual}".`);
     }
 };

internal/gen.ts

@@ -3,7 +3,6 @@ import {mapPoints} from "../internal/util";
 import {BlobOptions} from "../public/blobs";
 import {Point} from "./types";
 import {smooth} from "./util";
-import {typeCheck} from "./errors";
 
 export const genBlob = (pointCount: number, offset: () => number): Point[] => {
     const angle = (Math.PI * 2) / pointCount;
@@ -28,12 +27,6 @@ export const genBlob = (pointCount: number, offset: () => number): Point[] => {
 };
 
 export const genFromOptions = (blobOptions: BlobOptions): Point[] => {
-    typeCheck("blobOptions", blobOptions, ["object"]);
-    typeCheck("seed", blobOptions.seed, ["string", "number"]);
-    typeCheck("extraPoints", blobOptions.extraPoints, ["number"]);
-    typeCheck("randomness", blobOptions.randomness, ["number"]);
-    typeCheck("size", blobOptions.size, ["number"]);
-
     const rgen = rand(String(blobOptions.seed));
 
     // Scale of random movement increases as randomness approaches infinity.
@@ -44,14 +37,14 @@ export const genFromOptions = (blobOptions: BlobOptions): Point[] => {
     // randomness = 20  -> rangeStart = 0.3333
     // randomness = 50  -> rangeStart = 0.1667
     // randomness = 100 -> rangeStart = 0.0909
-    const rangeStart = 1 / (1 + Math.abs(blobOptions.randomness) / 10);
+    const rangeStart = 1 / (1 + blobOptions.randomness / 10);
 
     const points = genBlob(
-        3 + Math.abs(blobOptions.extraPoints),
+        3 + blobOptions.extraPoints,
         () => (rangeStart + rgen() * (1 - rangeStart)) / 2,
     );
 
-    const size = Math.abs(blobOptions.size);
+    const size = blobOptions.size;
     return mapPoints(points, ({curr}) => {
         curr.x *= size;
         curr.y *= size;

public/animate.ts

@@ -3,7 +3,8 @@ import {renderPath2D} from "../internal/render/canvas";
 import {genFromOptions} from "../internal/gen";
 import {mapPoints} from "../internal/util";
 import {statefulAnimationGenerator} from "../internal/animate/state";
-import {typeCheck} from "../internal/errors";
+import {typeCheck, err} from "../internal/errors";
+import {timingFunctions} from "../internal/animate/timing";
 
 export interface CanvasKeyframe {
     delay?: number;
@@ -38,8 +39,34 @@ const canvasBlobGenerator = (keyframe: CanvasKeyframe): Point[] => {
     });
 };
 
-// Only need to check properties unique to the canvas animation generator.
+// TODO make reusable.
 const canvasKeyframeChecker = (keyframe: CanvasKeyframe, index: number) => {
+    // keyframe options
+    typeCheck(`keyframes[${index}]`, keyframe, ["object"]);
+    const {delay, duration, timingFunction, callback} = keyframe;
+    typeCheck(`keyframes[${index}].delay`, delay, ["number", "undefined"]);
+    if (delay && delay < 0) err(`keyframes[${index}].delay is invalid "${delay}".`);
+    typeCheck(`keyframes[${index}].duration`, duration, ["number"]);
+    if (duration && duration < 0) err(`keyframes[${index}].duration is invalid "${duration}".`);
+    typeCheck(`keyframes[${index}].timingFunction`, timingFunction, ["string", "undefined"]);
+    if (timingFunction && !timingFunctions[timingFunction])
+        err(`"keyframes[${index}].timingFunction" is not recognized "${timingFunction}".`);
+    typeCheck(`keyframes[${index}].callback`, callback, ["function", "undefined"]);
+
+    // blobOptions
+    typeCheck(`keyframes[${index}].blobOptions`, keyframe.blobOptions, ["object"]);
+    const {seed, extraPoints, randomness, size} = keyframe.blobOptions;
+    typeCheck(`keyframes[${index}].blobOptions.seed`, seed, ["string", "number"]);
+    typeCheck(`keyframes[${index}].blobOptions.extraPoints`, extraPoints, ["number"]);
+    if (extraPoints < 0)
+        err(`keyframes[${index}].blobOptions.extraPoints is invalid "${extraPoints}".`);
+    typeCheck(`keyframes[${index}].blobOptions.randomness`, randomness, ["number"]);
+    if (randomness < 0)
+        err(`keyframes[${index}].blobOptions.randomness is invalid "${randomness}".`);
+    typeCheck(`keyframes[${index}].blobOptions.size`, size, ["number"]);
+    if (size < 0) err(`keyframes[${index}].blobOptions.size is invalid "${size}".`);
+
+    // canvasOptions
     typeCheck(`keyframes[${index}].canvasOptions`, keyframe.canvasOptions, ["object", "undefined"]);
     if (keyframe.canvasOptions) {
         const {offsetX, offsetY} = keyframe.canvasOptions;