standardize options variable naming

Author: g-harel

internal/animate/prepare.ts

@@ -12,7 +12,7 @@ import {
 } from "../util";
 import {Point} from "../types";
 
-// OPT extract optimization logic
+// TODO OPT extract optimization logic
 const optimizeOrder = (a: Point[], b: Point[]): Point[] => {
     const count = a.length;
 
@@ -40,7 +40,7 @@ const optimizeOrder = (a: Point[], b: Point[]): Point[] => {
     return shift(minOffset, minOffsetBase);
 };
 
-// OPT allow extra division
+// TODO OPT allow extra division
 export const divide = (count: number, points: Point[]): Point[] => {
     if (points.length < 3) throw new Error("not enough points");
     if (count < points.length) throw new Error("cannot remove points");
@@ -65,7 +65,7 @@ export const divide = (count: number, points: Point[]): Point[] => {
     return out;
 };
 
-// OPT disable
+// TODO OPT disable
 const fixAnglesWith = (fixee: Point[], fixer: Point[]): Point[] => {
     return mapPoints(fixee, ({index, curr, prev, next}) => {
         if (curr.handleIn.length === 0 && coordEqual(prev(), curr)) {
@@ -78,7 +78,7 @@ const fixAnglesWith = (fixee: Point[], fixer: Point[]): Point[] => {
     });
 };
 
-// OPT disable
+// TODO OPT disable
 const fixAnglesSelf = (points: Point[]): Point[] => {
     return mapPoints(points, ({curr, prev, next}) => {
         const angle = angleOf(prev(), next());

internal/render/svg.ts

@@ -37,40 +37,40 @@ export const renderPath = (points: Point[]): string => {
 };
 
 // Renders the input points to an editable data structure which can be rendered to svg.
-export const renderEditable = (points: Point[], opt: RenderOptions): XmlElement => {
-    const stroke = opt.stroke || (opt.guides ? "black" : "none");
-    const strokeWidth = opt.strokeWidth || (opt.guides ? 1 : 0);
+export const renderEditable = (points: Point[], options: RenderOptions): XmlElement => {
+    const stroke = options.stroke || (options.guides ? "black" : "none");
+    const strokeWidth = options.strokeWidth || (options.guides ? 1 : 0);
 
     const xmlRoot = xml("svg");
-    xmlRoot.attributes.width = opt.width;
-    xmlRoot.attributes.height = opt.height;
-    xmlRoot.attributes.viewBox = `0 0 ${opt.width} ${opt.height}`;
+    xmlRoot.attributes.width = options.width;
+    xmlRoot.attributes.height = options.height;
+    xmlRoot.attributes.viewBox = `0 0 ${options.width} ${options.height}`;
     xmlRoot.attributes.xmlns = "http://www.w3.org/2000/svg";
 
     const xmlContentGroup = xml("g");
-    xmlContentGroup.attributes.transform = opt.transform || "";
+    xmlContentGroup.attributes.transform = options.transform || "";
 
     const xmlBlobPath = xml("path");
     xmlBlobPath.attributes.stroke = stroke;
     xmlBlobPath.attributes["stroke-width"] = strokeWidth;
-    xmlBlobPath.attributes.fill = opt.fill || "none";
+    xmlBlobPath.attributes.fill = options.fill || "none";
     xmlBlobPath.attributes.d = renderPath(points);
 
     xmlContentGroup.children.push(xmlBlobPath);
     xmlRoot.children.push(xmlContentGroup);
 
     // Render guides if configured to do so.
-    if (opt.guides) {
-        const color = opt.stroke || "black";
-        const size = opt.strokeWidth || 1;
+    if (options.guides) {
+        const color = options.stroke || "black";
+        const size = options.strokeWidth || 1;
 
         // Bounding box.
-        if (opt.boundingBox) {
+        if (options.boundingBox) {
             const xmlBoundingRect = xml("rect");
             xmlBoundingRect.attributes.x = 0;
             xmlBoundingRect.attributes.y = 0;
-            xmlBoundingRect.attributes.width = opt.width;
-            xmlBoundingRect.attributes.height = opt.height;
+            xmlBoundingRect.attributes.width = options.width;
+            xmlBoundingRect.attributes.height = options.height;
             xmlBoundingRect.attributes.fill = "none";
             xmlBoundingRect.attributes.stroke = color;
             xmlBoundingRect.attributes["stroke-width"] = 2 * size;

legacy/blobs.ts

@@ -41,47 +41,47 @@ export interface BlobOptions extends PathOptions {
 }
 
 // Generates an svg document string containing a randomized blob.
-const blobs = (opt: BlobOptions): string => {
-    return blobs.editable(opt).render();
+const blobs = (options: BlobOptions): string => {
+    return blobs.editable(options).render();
 };
 
 // Generates a randomized blob as an editable data structure which can be rendered to an svg document.
-blobs.editable = (opt: BlobOptions): XmlElement => {
-    if (!opt) {
+blobs.editable = (options: BlobOptions): XmlElement => {
+    if (!options) {
         throw new Error("no options specified");
     }
 
     // Random number generator.
-    const rgen = rand(opt.seed || String(Date.now()));
+    const rgen = rand(options.seed || String(Date.now()));
 
-    if (!opt.size) {
+    if (!options.size) {
         throw new Error("no size specified");
     }
 
-    if (!opt.stroke && !opt.color) {
+    if (!options.stroke && !options.color) {
         throw new Error("no color or stroke specified");
     }
 
-    if (opt.complexity <= 0 || opt.complexity > 1) {
+    if (options.complexity <= 0 || options.complexity > 1) {
         throw new Error("complexity out of range ]0,1]");
     }
 
-    if (opt.contrast < 0 || opt.contrast > 1) {
+    if (options.contrast < 0 || options.contrast > 1) {
         throw new Error("contrast out of range [0,1]");
     }
 
-    const count = 3 + Math.floor(14 * opt.complexity);
-    const offset = (): number => (1 - 0.8 * opt.contrast * rgen()) / Math.E;
+    const count = 3 + Math.floor(14 * options.complexity);
+    const offset = (): number => (1 - 0.8 * options.contrast * rgen()) / Math.E;
 
     const points = mapPoints(genBlob(count, offset), ({curr}) => {
         // Scale.
-        curr.x *= opt.size;
-        curr.y *= opt.size;
-        curr.handleIn.length *= opt.size;
-        curr.handleOut.length *= opt.size;
+        curr.x *= options.size;
+        curr.y *= options.size;
+        curr.handleIn.length *= options.size;
+        curr.handleOut.length *= options.size;
 
         // Flip around x-axis.
-        curr.y = opt.size - curr.y;
+        curr.y = options.size - curr.y;
         curr.handleIn.angle *= -1;
         curr.handleOut.angle *= -1;
 
@@ -90,13 +90,13 @@ blobs.editable = (opt: BlobOptions): XmlElement => {
 
     return renderEditable(points, {
         closed: true,
-        width: opt.size,
-        height: opt.size,
-        fill: opt.color,
-        transform: `rotate(${rgen() * (360 / count)},${opt.size / 2},${opt.size / 2})`,
-        stroke: opt.stroke && opt.stroke.color,
-        strokeWidth: opt.stroke && opt.stroke.width,
-        guides: opt.guides,
+        width: options.size,
+        height: options.size,
+        fill: options.color,
+        transform: `rotate(${rgen() * (360 / count)},${options.size / 2},${options.size / 2})`,
+        stroke: options.stroke && options.stroke.color,
+        strokeWidth: options.stroke && options.stroke.width,
+        guides: options.guides,
     });
 };
 

public/gen.ts

@@ -12,8 +12,8 @@ export interface Blob {
     points: Point[];
 }
 
-export const gen = (opt: GenOptions): Blob => {
-    const rgen = rand(String(opt.seed));
+export const gen = (options: GenOptions): Blob => {
+    const rgen = rand(String(options.seed));
 
     // Scale of random movement increases as randomness approaches infinity.
     // randomness = 0   -> rangeStart = 1
@@ -23,11 +23,11 @@ export const gen = (opt: GenOptions): Blob => {
     // randomness = 20  -> rangeStart = 0.3333
     // randomness = 50  -> rangeStart = 0.1667
     // randomness = 100 -> rangeStart = 0.0909
-    const rangeStart = 1 / (1 + Math.abs(opt.randomness) / 10);
+    const rangeStart = 1 / (1 + Math.abs(options.randomness) / 10);
 
     return {
         points: genBlob(
-            3 + Math.abs(opt.extraPoints),
+            3 + Math.abs(options.extraPoints),
             () => rangeStart + rgen() * (1 - rangeStart),
         ),
     };