@thi.ng/axidraw 0.5.8 → 1.0.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-03-14T13:27:19Z
+- **Last updated**: 2023-03-19T14:07:45Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,38 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [1.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/axidraw@1.0.0) (2023-03-19)
+
+#### 🛑 Breaking changes
+
+- add/update command presets ([610f873](https://github.com/thi-ng/umbrella/commit/610f873))
+- BREAKING CHANGE: update DrawCommands and cmd presets
+  - update MoveXYCommand to use `"M"`
+  - add MoveRelCommand (using `"m"`)
+  - add/update AxiDraw.moveTo()/moveRelative()
+  - migrate command presets to commands.ts
+  - refactor parametric command type presets as functions:
+    -  PEN(), UP(), DOWN(), MOVE(), MOVE_REL(), WAIT(), COMMENT()
+  - add DIP() command sequence gen
+
+#### 🚀 Features
+
+- add command fns, add COMMENT cmd ([0d64b55](https://github.com/thi-ng/umbrella/commit/0d64b55))
+  - add MOVE(), WAIT(), COMMENT()
+  - add CommentCommand
+  - update AxiDraw.draw() to log comments
+- add disconnect() ([af93177](https://github.com/thi-ng/umbrella/commit/af93177))
+  - add disconnect() for ISerial & AxiDraw
+  - update MockSerial impl
+- update commands, docs & pkg exports ([1324cb8](https://github.com/thi-ng/umbrella/commit/1324cb8))
+- update dip(), update imports. restructure /src ([b108760](https://github.com/thi-ng/umbrella/commit/b108760))
+  - add DipOpts, extend dip() functionality
+  - move dip() to own file dip.ts
+  - move complete() to commands.ts
+  - move registrationMark() to own file registration.ts
+  - update all imports
+  - update pkg exports map
+
 ## [0.5.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/axidraw@0.5.0) (2023-02-05)
 
 #### 🚀 Features

package/README.md

@@ -25,6 +25,8 @@ This project is part of the
   - [Example usage](#example-usage)
     - [Basics](#basics)
   - [geom-axidraw example](#geom-axidraw-example)
+  - [Available draw commands](#available-draw-commands)
+    - [Command sequence generators](#command-sequence-generators)
 - [Authors](#authors)
 - [License](#license)
 
@@ -164,7 +166,7 @@ For Node.js REPL:
 const axidraw = await import("@thi.ng/axidraw");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 2.15 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 2.46 KB
 
 ## Dependencies
 
@@ -259,14 +261,46 @@ import { map, range } from "@thi.ng/transducers";
 
 Other selected toots/tweets:
 
-- https://mastodon.thi.ng/@toxi/109490174709589253
-- https://mastodon.thi.ng/@toxi/109473655772673067
-- https://mastodon.thi.ng/@toxi/109474947869078797
-- https://mastodon.thi.ng/@toxi/109483553358349473
-- https://mastodon.thi.ng/@toxi/109570540391689321
-- https://mastodon.thi.ng/@toxi/109586780630493994
+- [Project announcement](https://mastodon.thi.ng/@toxi/109490174709589253)
+- [Geometry conversion basics](https://mastodon.thi.ng/@toxi/109473655772673067)
+- [Shape group conversion and stippling](https://mastodon.thi.ng/@toxi/109474947869078797)
+- [Per-shape & on-the-fly polyline clipping](https://mastodon.thi.ng/@toxi/109483553358349473)
+- [Bitmap-to-vector conversions & shape sorting](https://mastodon.thi.ng/@toxi/109570540391689321)
+- [Multi-color plotting](https://mastodon.thi.ng/@toxi/109586780630493994)
+- [Using water color & paintbrush](https://mastodon.thi.ng/@toxi/110044424626641749)
 - more to come...
 
+### Available draw commands
+
+All
+[`DrawCommand`s](https://docs.thi.ng/umbrella/axidraw/types/DrawCommand.html)
+are expressed as S-expression-like, [thi.ng/hiccup]()-style elements, aka JS
+arrays/tuples of `[command, ...args]`. The following commands are supported. All
+also as predefined constants or factory functions for the parametric ones:
+
+| Command                           | Preset/factory                                                                                                                      |
+|-----------------------------------|-------------------------------------------------------------------------------------------------------------------------------------|
+| `["comment", msg]`                | [`COMMENT`](https://docs.thi.ng/umbrella/axidraw/functions/COMMENT.html)                                                            |
+| `["d", delay?]` / `["u", delay?]` | [`DOWN`](https://docs.thi.ng/umbrella/axidraw/functions/DOWN.html) / [`UP`](https://docs.thi.ng/umbrella/axidraw/functions/UP.html) |
+| `["home"]`                        | `HOME`                                                                                                                              |
+| `["m", [x,y], speed?]`            | [`MOVE_REL`](https://docs.thi.ng/umbrella/axidraw/functions/MOVE_REL.html)                                                          |
+| `["M", [x,y], speed?]`            | [`MOVE`](https://docs.thi.ng/umbrella/axidraw/functions/MOVE.html)                                                                  |
+| `["on"]` / `["off"]`              | `ON` / `OFF`                                                                                                                        |
+| `["pen", down, up]`               | [`PEN`](https://docs.thi.ng/umbrella/axidraw/functions/PEN.html)                                                                    |
+| `["reset"]`                       | `RESET`                                                                                                                             |
+| `["start"]`                       | `START`                                                                                                                             |
+| `["stop"]`                        | `STOP`                                                                                                                              |
+| `["w", delay]`                    | [`WAIT`](https://docs.thi.ng/umbrella/axidraw/functions/WAIT.html)                                                                  |
+
+#### Command sequence generators
+
+Additionally, the following command sequence generators are provided (see their docs for code examples):
+
+- [`complete`](https://docs.thi.ng/umbrella/axidraw/functions/complete.html)
+- [`dip`](https://docs.thi.ng/umbrella/axidraw/functions/dip.html)
+- [`polyline`](https://docs.thi.ng/umbrella/axidraw/functions/polyline.html)
+- [`registrationMark`](https://docs.thi.ng/umbrella/axidraw/functions/registrationMark.html)
+
 ## Authors
 
 - [Karsten Schmidt](https://thi.ng)

package/api.d.ts

@@ -23,10 +23,17 @@ export type PenUpDownCommand = ["u" | "d", number?, number?];
  * Move to abs pos (in worldspace coords, default mm), optional speed factor
  * (default: 1)
  */
-export type MoveXYCommand = ["m", ReadonlyVec, number?];
+export type MoveXYCommand = ["M", ReadonlyVec, number?];
+/**
+ * Move to **relative** pos (based on curr plotter position, im worldspace
+ * units, default mm), optional speed factor (default: 1)
+ */
+export type MoveRelCommand = ["m", ReadonlyVec, number?];
 /** Explicit delay (in ms) */
 export type WaitCommand = ["w", number];
-export type DrawCommand = StartCommand | StopCommand | HomeCommand | ResetCommand | MotorCommand | PenConfigCommand | PenUpDownCommand | MoveXYCommand | WaitCommand;
+/** Ignored, but will be logged (if logging enabled) */
+export type CommentCommand = ["comment", string];
+export type DrawCommand = StartCommand | StopCommand | HomeCommand | ResetCommand | MotorCommand | PenConfigCommand | PenUpDownCommand | MoveXYCommand | MoveRelCommand | WaitCommand | CommentCommand;
 /**
  * Global plotter drawing configuration. Also see {@link DEFAULT_OPTS}.
  */
@@ -137,15 +144,6 @@ export interface AxiDrawOpts {
      */
     sigint: boolean;
 }
-export declare const START: StartCommand;
-export declare const STOP: StopCommand;
-export declare const HOME: HomeCommand;
-export declare const RESET: ResetCommand;
-export declare const PEN: PenConfigCommand;
-export declare const UP: PenUpDownCommand;
-export declare const DOWN: PenUpDownCommand;
-export declare const ON: MotorCommand;
-export declare const OFF: MotorCommand;
 /**
  * FSM state enum for (interactive) control for processing of drawing commands.
  * See {@link AxiDraw.draw} and {@link AxiDrawControl} for details.
@@ -245,6 +243,7 @@ export interface SerialConnection {
     ctor(path: string, baudRate: number): ISerial;
 }
 export interface ISerial {
+    close(): void;
     /**
      * Writes given string to the port.
      *

package/api.js

@@ -1,12 +1,3 @@
-export const START = ["start"];
-export const STOP = ["stop"];
-export const HOME = ["home"];
-export const RESET = ["reset"];
-export const PEN = ["pen"];
-export const UP = ["u"];
-export const DOWN = ["d"];
-export const ON = ["on"];
-export const OFF = ["off"];
 /**
  * FSM state enum for (interactive) control for processing of drawing commands.
  * See {@link AxiDraw.draw} and {@link AxiDrawControl} for details.

package/axidraw.d.ts

@@ -1,5 +1,5 @@
 import type { IReset } from "@thi.ng/api";
-import { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import { ReadonlyVec, Vec } from "@thi.ng/vectors/api";
 import { AxiDrawOpts, DrawCommand, ISerial, Metrics } from "./api.js";
 export declare const DEFAULT_OPTS: AxiDrawOpts;
 export declare class AxiDraw implements IReset {
@@ -25,6 +25,7 @@ export declare class AxiDraw implements IReset {
      * @param path
      */
     connect(path?: string | RegExp): Promise<void>;
+    disconnect(): void;
     /**
      * Async function. Converts sequence of {@link DrawCommand}s into actual EBB
      * commands and sends them via configured serial port to the AxiDraw. If
@@ -85,12 +86,20 @@ export declare class AxiDraw implements IReset {
      * @param tempo
      */
     moveTo(p: ReadonlyVec, tempo?: number): number[];
+    /**
+     * Similar to {@link AxiDraw.moveTo}, but using **relative** coordinates.
+     *
+     * @param delta
+     * @param tempo
+     */
+    moveRelative(delta: ReadonlyVec, tempo?: number): number[];
     /**
      * Syntax sugar for {@link AxiDraw.moveTo}([0, 0]).
      */
     home(): number[];
     protected onSignal(): Promise<void>;
     protected send(msg: string): void;
+    protected sendMove(tempo?: number): number[];
     /**
      * Sends pen up/down config
      *

package/axidraw.js

@@ -1,12 +1,21 @@
-import { isString } from "@thi.ng/checks";
-import { delayed } from "@thi.ng/compose";
-import { formatDuration } from "@thi.ng/date";
-import { assert, ioerror, unsupported } from "@thi.ng/errors";
-import { ConsoleLogger } from "@thi.ng/logger";
-import { abs2, mag, mulN2, set2, sub2, zero, ZERO2, } from "@thi.ng/vectors";
-import { AxiDrawState, HOME, OFF, ON, PEN, UP, } from "./api.js";
+import { isString } from "@thi.ng/checks/is-string";
+import { delayed } from "@thi.ng/compose/delayed";
+import { formatDuration } from "@thi.ng/date/format";
+import { assert } from "@thi.ng/errors/assert";
+import { ioerror } from "@thi.ng/errors/io";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { ConsoleLogger } from "@thi.ng/logger/console";
+import { abs2 } from "@thi.ng/vectors/abs";
+import { ZERO2 } from "@thi.ng/vectors/api";
+import { maddN2 } from "@thi.ng/vectors/maddn";
+import { mag } from "@thi.ng/vectors/mag";
+import { mulN2 } from "@thi.ng/vectors/muln";
+import { set2 } from "@thi.ng/vectors/set";
+import { zero } from "@thi.ng/vectors/setn";
+import { sub2 } from "@thi.ng/vectors/sub";
+import { AxiDrawState, } from "./api.js";
+import { complete, HOME, OFF, ON, PEN, UP } from "./commands.js";
 import { AxiDrawControl } from "./control.js";
-import { complete } from "./polyline.js";
 import { SERIAL_PORT } from "./serial.js";
 export const DEFAULT_OPTS = {
     serial: SERIAL_PORT,
@@ -22,8 +31,8 @@ export const DEFAULT_OPTS = {
     delayUp: 150,
     delayDown: 150,
     preDelay: 0,
-    start: [ON, PEN, UP],
-    stop: [UP, HOME, OFF],
+    start: [ON, PEN(), UP()],
+    stop: [UP(), HOME, OFF],
     sigint: true,
 };
 export class AxiDraw {
@@ -70,6 +79,9 @@ export class AxiDraw {
         }
         ioerror(`no matching device for ${path}`);
     }
+    disconnect() {
+        this.serial.close();
+    }
     /**
      * Async function. Converts sequence of {@link DrawCommand}s into actual EBB
      * commands and sends them via configured serial port to the AxiDraw. If
@@ -176,10 +188,17 @@ export class AxiDraw {
                 case "w":
                     wait = a;
                     break;
-                case "m":
+                case "M":
                     [wait, dist] = this.moveTo(a, b);
                     $recordDist(dist);
                     break;
+                case "m":
+                    [wait, dist] = this.moveRelative(a, b);
+                    $recordDist(dist);
+                    break;
+                case "comment":
+                    logger.info(`comment: ${a}`);
+                    break;
                 default:
                     unsupported(`unknown command: ${$cmd}`);
             }
@@ -258,17 +277,23 @@ export class AxiDraw {
      * @param p
      * @param tempo
      */
-    moveTo(p, tempo = 1) {
-        const { pos, targetPos, opts, isPenDown } = this;
+    moveTo(p, tempo) {
+        const { targetPos, opts } = this;
         // apply scale factor: worldspace units -> motor steps
         mulN2(targetPos, p, opts.stepsPerInch / opts.unitsPerInch);
-        const delta = sub2([], targetPos, pos);
-        set2(pos, targetPos);
-        const maxAxis = Math.max(...abs2([], delta));
-        const duration = (1000 * maxAxis) /
-            ((isPenDown ? opts.speedDown : opts.speedUp) * tempo);
-        this.send(`XM,${duration | 0},${delta[0] | 0},${delta[1] | 0}\r`);
-        return [duration, (mag(delta) * opts.unitsPerInch) / opts.stepsPerInch];
+        return this.sendMove(tempo);
+    }
+    /**
+     * Similar to {@link AxiDraw.moveTo}, but using **relative** coordinates.
+     *
+     * @param delta
+     * @param tempo
+     */
+    moveRelative(delta, tempo) {
+        const { pos, targetPos, opts } = this;
+        // apply scale factor: worldspace units -> motor steps
+        maddN2(targetPos, delta, opts.stepsPerInch / opts.unitsPerInch, pos);
+        return this.sendMove(tempo);
     }
     /**
      * Syntax sugar for {@link AxiDraw.moveTo}([0, 0]).
@@ -287,6 +312,16 @@ export class AxiDraw {
         this.opts.logger.debug(msg);
         this.serial.write(msg);
     }
+    sendMove(tempo = 1) {
+        const { pos, targetPos, opts, isPenDown } = this;
+        const delta = sub2([], targetPos, pos);
+        set2(pos, targetPos);
+        const maxAxis = Math.max(...abs2([], delta));
+        const duration = (1000 * maxAxis) /
+            ((isPenDown ? opts.speedDown : opts.speedUp) * tempo);
+        this.send(`XM,${duration | 0},${delta[0] | 0},${delta[1] | 0}\r`);
+        return [duration, (mag(delta) * opts.unitsPerInch) / opts.stepsPerInch];
+    }
     /**
      * Sends pen up/down config
      *

package/commands.d.ts

@@ -0,0 +1,67 @@
+import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { CommentCommand, DrawCommand, HomeCommand, MotorCommand, MoveRelCommand, MoveXYCommand, PenConfigCommand, PenUpDownCommand, ResetCommand, StartCommand, StopCommand, WaitCommand } from "./api.js";
+export declare const START: StartCommand;
+export declare const STOP: StopCommand;
+export declare const HOME: HomeCommand;
+export declare const RESET: ResetCommand;
+/**
+ * Creates a {@link PenConfigCommand} using provided down/up positions.
+ *
+ * @param posDown
+ * @param posUp
+ */
+export declare const PEN: (posDown?: number, posUp?: number) => PenConfigCommand;
+/**
+ * Creates a {@link PenUpDownCommand} to move the pen up.
+ *
+ * @param delay
+ */
+export declare const UP: (delay?: number) => PenUpDownCommand;
+/**
+ * Creates a {@link PenUpDownCommand} to move the pen down.
+ *
+ * @param delay
+ */
+export declare const DOWN: (delay?: number) => PenUpDownCommand;
+export declare const ON: MotorCommand;
+export declare const OFF: MotorCommand;
+/**
+ * Creates a {@link MoveXYCommand} command (absolute coordinates).
+ *
+ * @param pos
+ * @param speed
+ */
+export declare const MOVE: (pos: ReadonlyVec, speed?: number) => MoveXYCommand;
+/**
+ * Creates a {@link MoveRelCommand} command (relative coordinates).
+ *
+ * @param delta
+ * @param speed
+ */
+export declare const MOVE_REL: (delta: ReadonlyVec, speed?: number) => MoveRelCommand;
+/**
+ * Creates a {@link WaitCommand}. Default delay is 1000 ms.
+ *
+ * @param delay
+ */
+export declare const WAIT: (delay?: number) => WaitCommand;
+/**
+ * Creates a {@link CommentCommand}.
+ *
+ * @param msg
+ */
+export declare const COMMENT: (msg: string) => CommentCommand;
+/**
+ * Syntax sugar. Takes an iterable of draw commands, adds {@link START} as
+ * prefix and {@link STOP} as suffix. I.e. it creates a "complete" drawing...
+ *
+ * @example
+ * ```ts
+ * [...complete([ MOVE([0, 0]) ])]
+ * // [ ["start"], ["M", [0, 0]], ["stop"] ]
+ * ```
+ *
+ * @param commands
+ */
+export declare function complete(commands: Iterable<DrawCommand>): Generator<DrawCommand, void, undefined>;
+//# sourceMappingURL=commands.d.ts.map

package/commands.js

@@ -0,0 +1,80 @@
+export const START = ["start"];
+export const STOP = ["stop"];
+export const HOME = ["home"];
+export const RESET = ["reset"];
+/**
+ * Creates a {@link PenConfigCommand} using provided down/up positions.
+ *
+ * @param posDown
+ * @param posUp
+ */
+export const PEN = (posDown, posUp) => [
+    "pen",
+    posDown,
+    posUp,
+];
+/**
+ * Creates a {@link PenUpDownCommand} to move the pen up.
+ *
+ * @param delay
+ */
+export const UP = (delay) => ["u", delay];
+/**
+ * Creates a {@link PenUpDownCommand} to move the pen down.
+ *
+ * @param delay
+ */
+export const DOWN = (delay) => ["d", delay];
+export const ON = ["on"];
+export const OFF = ["off"];
+/**
+ * Creates a {@link MoveXYCommand} command (absolute coordinates).
+ *
+ * @param pos
+ * @param speed
+ */
+export const MOVE = (pos, speed = 1) => [
+    "M",
+    pos,
+    speed,
+];
+/**
+ * Creates a {@link MoveRelCommand} command (relative coordinates).
+ *
+ * @param delta
+ * @param speed
+ */
+export const MOVE_REL = (delta, speed = 1) => [
+    "m",
+    delta,
+    speed,
+];
+/**
+ * Creates a {@link WaitCommand}. Default delay is 1000 ms.
+ *
+ * @param delay
+ */
+export const WAIT = (delay = 1000) => ["w", delay];
+/**
+ * Creates a {@link CommentCommand}.
+ *
+ * @param msg
+ */
+export const COMMENT = (msg) => ["comment", msg];
+/**
+ * Syntax sugar. Takes an iterable of draw commands, adds {@link START} as
+ * prefix and {@link STOP} as suffix. I.e. it creates a "complete" drawing...
+ *
+ * @example
+ * ```ts
+ * [...complete([ MOVE([0, 0]) ])]
+ * // [ ["start"], ["M", [0, 0]], ["stop"] ]
+ * ```
+ *
+ * @param commands
+ */
+export function* complete(commands) {
+    yield START;
+    yield* commands;
+    yield STOP;
+}

package/dip.d.ts

@@ -0,0 +1,60 @@
+import type { Fn0 } from "@thi.ng/api";
+import type { DrawCommand } from "./api.js";
+export interface DipOpts {
+    /**
+     * Delay for emitted {@link DOWN} commands. If omitted, uses globally
+     * configured default.
+     */
+    up: number;
+    /**
+     * Delay for emitted {@link UP} commands. If omitted, uses globally
+     * configured default.
+     */
+    down: number;
+    /**
+     * No-arg function to inject custom commands between each down - up command.
+     * See example in {@link DIP} docs.
+     */
+    commands: Fn0<Iterable<DrawCommand>>;
+}
+/**
+ * Yields a **sequence** of `n` repetitions of {@link DOWN}, {@link UP}
+ * commands, optionally interspersed with other user provided
+ * {@link DrawCommand}s, e.g. for dipping & moving a brush a few times into a
+ * paint reservoir to refill.
+ *
+ * @example
+ * ```ts
+ * // simple 2x up/down
+ * [...DIP(2)]
+ * // [
+ * //   [ "d", undefined ],
+ * //   [ "u", undefined ],
+ * //   [ "d", undefined ],
+ * //   [ "u", undefined ],
+ * // ]
+ *
+ * // 3x dipping with custom up/down delays, each time at a random position
+ * [...DIP(3, {
+ *   down: 300,
+ *   up: 400,
+ *   commands: () => [ MOVE([Math.random()* 5, Math.random()* 5]) ]
+ * })]
+ * // [
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 3.996, 1.707 ], 1 ],
+ * //   [ "u", 400 ],
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 4.747, 4.925 ], 1 ],
+ * //   [ "u", 400 ],
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 1.751, 0.670 ], 1 ],
+ * //   [ "u", 400 ]
+ * // ]
+ * ```
+ *
+ * @param n
+ * @param opts
+ */
+export declare const dip: (n: number, opts?: Partial<DipOpts>) => IterableIterator<DrawCommand>;
+//# sourceMappingURL=dip.d.ts.map

package/dip.js

@@ -0,0 +1,45 @@
+import { flatten1 } from "@thi.ng/transducers/flatten1";
+import { repeatedly } from "@thi.ng/transducers/repeatedly";
+import { DOWN, UP } from "./commands.js";
+/**
+ * Yields a **sequence** of `n` repetitions of {@link DOWN}, {@link UP}
+ * commands, optionally interspersed with other user provided
+ * {@link DrawCommand}s, e.g. for dipping & moving a brush a few times into a
+ * paint reservoir to refill.
+ *
+ * @example
+ * ```ts
+ * // simple 2x up/down
+ * [...DIP(2)]
+ * // [
+ * //   [ "d", undefined ],
+ * //   [ "u", undefined ],
+ * //   [ "d", undefined ],
+ * //   [ "u", undefined ],
+ * // ]
+ *
+ * // 3x dipping with custom up/down delays, each time at a random position
+ * [...DIP(3, {
+ *   down: 300,
+ *   up: 400,
+ *   commands: () => [ MOVE([Math.random()* 5, Math.random()* 5]) ]
+ * })]
+ * // [
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 3.996, 1.707 ], 1 ],
+ * //   [ "u", 400 ],
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 4.747, 4.925 ], 1 ],
+ * //   [ "u", 400 ],
+ * //   [ "d", 300 ],
+ * //   [ "M", [ 1.751, 0.670 ], 1 ],
+ * //   [ "u", 400 ]
+ * // ]
+ * ```
+ *
+ * @param n
+ * @param opts
+ */
+export const dip = (n, opts = {}) => flatten1(repeatedly(opts.commands
+    ? () => [DOWN(opts.down), ...opts.commands(), UP(opts.up)]
+    : () => [DOWN(opts.down), UP(opts.up)], n));

package/index.d.ts

@@ -1,7 +1,9 @@
 export * from "./api.js";
 export * from "./axidraw.js";
+export * from "./commands.js";
 export * from "./control.js";
+export * from "./dip.js";
 export * from "./polyline.js";
+export * from "./registration.js";
 export * from "./serial.js";
-export * from "./utils.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,6 +1,8 @@
 export * from "./api.js";
 export * from "./axidraw.js";
+export * from "./commands.js";
 export * from "./control.js";
+export * from "./dip.js";
 export * from "./polyline.js";
+export * from "./registration.js";
 export * from "./serial.js";
-export * from "./utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/axidraw",
-  "version": "0.5.8",
+  "version": "1.0.0",
   "description": "Minimal AxiDraw plotter/drawing machine controller for Node.js",
   "type": "module",
   "module": "./index.js",
@@ -40,8 +40,8 @@
     "@thi.ng/date": "^2.4.8",
     "@thi.ng/errors": "^2.2.13",
     "@thi.ng/logger": "^1.4.11",
-    "@thi.ng/transducers": "^8.3.38",
-    "@thi.ng/vectors": "^7.6.8",
+    "@thi.ng/transducers": "^8.4.0",
+    "@thi.ng/vectors": "^7.6.9",
     "serialport": "^10.5.0"
   },
   "devDependencies": {
@@ -87,22 +87,28 @@
     "./axidraw": {
       "default": "./axidraw.js"
     },
+    "./commands": {
+      "default": "./commands.js"
+    },
     "./control": {
       "default": "./control.js"
     },
+    "./dip": {
+      "default": "./dip.js"
+    },
     "./polyline": {
       "default": "./polyline.js"
     },
+    "./registration": {
+      "default": "./registration.js"
+    },
     "./serial": {
       "default": "./serial.js"
-    },
-    "./utils": {
-      "default": "./utils.js"
     }
   },
   "thi.ng": {
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "cc46c097a3a173fb1ef41f57a858d03037063141\n"
+  "gitHead": "1359645f3af8a7d0d43fe7944ea5cd865832f8ee\n"
 }

package/polyline.d.ts

@@ -1,5 +1,5 @@
 import type { ReadonlyVec } from "@thi.ng/vectors";
-import { DrawCommand, PolylineOpts } from "./api.js";
+import type { DrawCommand, PolylineOpts } from "./api.js";
 /**
  * Takes an array of 2D points and yields an iterable of {@link DrawCommand}s.
  * The drawing behavior can be customized via additional {@link PolylineOpts}
@@ -13,17 +13,4 @@ import { DrawCommand, PolylineOpts } from "./api.js";
  * @param opts
  */
 export declare function polyline(pts: ReadonlyVec[], opts: Partial<PolylineOpts>): IterableIterator<DrawCommand>;
-/**
- * Syntax sugar. Takes an iterable of draw commands, adds {@link START} as
- * prefix and {@link STOP} as suffix. I.e. it creates a "complete" drawing...
- *
- * @example
- * ```ts
- * [...complete([ ["m", [0, 0]] ])]
- * // [ ["start"], ["m", [0, 0]], ["stop"] ]
- * ```
- *
- * @param commands
- */
-export declare function complete(commands: Iterable<DrawCommand>): Generator<DrawCommand, void, undefined>;
 //# sourceMappingURL=polyline.d.ts.map

package/polyline.js

@@ -1,4 +1,4 @@
-import { DOWN, START, STOP, UP } from "./api.js";
+import { DOWN, MOVE, PEN, UP } from "./commands.js";
 /**
  * Takes an array of 2D points and yields an iterable of {@link DrawCommand}s.
  * The drawing behavior can be customized via additional {@link PolylineOpts}
@@ -21,34 +21,17 @@ export function* polyline(pts, opts) {
     };
     if (onlyGeo) {
         for (let p of pts)
-            yield ["m", p, speed];
+            yield MOVE(p, speed);
         return;
     }
-    yield ["m", pts[0]];
+    yield MOVE(pts[0]);
     if (down !== undefined)
-        yield ["pen", down];
-    yield delayDown != undefined ? ["d", delayDown] : DOWN;
+        yield PEN(down);
+    yield DOWN(delayDown);
     for (let i = 1, n = pts.length; i < n; i++)
-        yield ["m", pts[i], speed];
-    yield delayUp != undefined ? ["u", delayUp] : UP;
+        yield MOVE(pts[i], speed);
+    yield UP(delayUp);
     // reset pen to configured defaults
     if (down !== undefined)
-        yield ["pen"];
-}
-/**
- * Syntax sugar. Takes an iterable of draw commands, adds {@link START} as
- * prefix and {@link STOP} as suffix. I.e. it creates a "complete" drawing...
- *
- * @example
- * ```ts
- * [...complete([ ["m", [0, 0]] ])]
- * // [ ["start"], ["m", [0, 0]], ["stop"] ]
- * ```
- *
- * @param commands
- */
-export function* complete(commands) {
-    yield START;
-    yield* commands;
-    yield STOP;
+        yield PEN();
 }

package/{utils.d.ts → registration.d.ts}

@@ -1,4 +1,4 @@
-import { ReadonlyVec } from "@thi.ng/vectors";
+import type { ReadonlyVec } from "@thi.ng/vectors";
 import type { DrawCommand } from "./api.js";
 /**
  * Generates a {@link DrawCommand} sequence to draw a registration mark
@@ -14,4 +14,4 @@ import type { DrawCommand } from "./api.js";
  * @param r
  */
 export declare const registrationMark: ([x, y]: ReadonlyVec, size?: number, r?: number) => DrawCommand[];
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=registration.d.ts.map

package/registration.js

@@ -0,0 +1,36 @@
+import { map } from "@thi.ng/transducers/map";
+import { normRange } from "@thi.ng/transducers/norm-range";
+import { cartesian2 } from "@thi.ng/vectors/cartesian";
+import { DOWN, MOVE, UP } from "./commands.js";
+/**
+ * Generates a {@link DrawCommand} sequence to draw a registration mark
+ * (crosshair + circle) centered around `pos`.
+ *
+ * @example
+ * ```ts
+ * axi.draw(registrationMark([20, 20]))
+ * ```
+ *
+ * @param pos
+ * @param size
+ * @param r
+ */
+export const registrationMark = ([x, y], size = 5, r = size * 0.75) => [
+    // crosshair
+    // horizontal
+    MOVE([x - size, y]),
+    DOWN(),
+    MOVE([x + size, y]),
+    UP(),
+    // vertical
+    MOVE([x, y - size]),
+    DOWN(),
+    MOVE([x, y + size]),
+    UP(),
+    // circle
+    MOVE([x + r, y]),
+    DOWN(),
+    ...map((t) => MOVE(cartesian2([], [r, t * Math.PI * 2], [x, y])), normRange(40)),
+    UP(),
+    MOVE([x, y]),
+];

package/serial.d.ts

@@ -14,10 +14,12 @@ export declare const MOCK_SERIAL: SerialConnection;
  */
 export declare class MockSerial implements ISerial {
     sent: string[];
+    isClosed: boolean;
     /**
      * Clears internal log of "sent" message.
      */
     clear(): void;
+    close(): void;
     /**
      * Appends
      * @param msg

package/serial.js

@@ -1,3 +1,4 @@
+import { illegalState } from "@thi.ng/errors/illegal-state";
 import { SerialPort } from "serialport";
 /**
  * Default connection using the actual serial port.
@@ -21,6 +22,7 @@ export const MOCK_SERIAL = {
 export class MockSerial {
     constructor() {
         this.sent = [];
+        this.isClosed = false;
     }
     /**
      * Clears internal log of "sent" message.
@@ -28,11 +30,15 @@ export class MockSerial {
     clear() {
         this.sent = [];
     }
+    close() {
+        this.isClosed = true;
+    }
     /**
      * Appends
      * @param msg
      */
     write(msg) {
+        this.isClosed && illegalState("connection already closed");
         this.sent.push(msg);
     }
 }

package/utils.js

@@ -1,34 +0,0 @@
-import { map, normRange } from "@thi.ng/transducers";
-import { cartesian2 } from "@thi.ng/vectors";
-/**
- * Generates a {@link DrawCommand} sequence to draw a registration mark
- * (crosshair + circle) centered around `pos`.
- *
- * @example
- * ```ts
- * axi.draw(registrationMark([20, 20]))
- * ```
- *
- * @param pos
- * @param size
- * @param r
- */
-export const registrationMark = ([x, y], size = 5, r = size * 0.75) => [
-    // crosshair
-    // horizontal
-    ["m", [x - size, y]],
-    ["d"],
-    ["m", [x + size, y]],
-    ["u"],
-    // vertical
-    ["m", [x, y - size]],
-    ["d"],
-    ["m", [x, y + size]],
-    ["u"],
-    // circle
-    ["m", [x + r, y]],
-    ["d"],
-    ...map((t) => ["m", cartesian2([], [r, t * Math.PI * 2], [x, y])], normRange(40)),
-    ["u"],
-    ["m", [x, y]],
-];