@angadie/chittie-transport 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Asyncdot Engineering
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+Portions of this software are vendored from MIT-licensed projects and retain
+their original copyright notices; see VENDOR.md.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# @angadie/chittie-transport
+
+The transport contract for chittie, plus helpers. A transport ships ESC/POS bytes to a printer — discovery, permissions, and connection details live in the platform adapter; this package is just the **send contract**. Zero runtime dependencies.
+
+## Install
+
+```bash
+pnpm add @angadie/chittie-transport
+```
+
+## The contract
+
+```ts
+interface Transport {
+  connect?(): Promise<void>;   // open the port / connect BLE / open socket
+  write(data: Uint8Array): Promise<void>;  // the one required method
+  disconnect?(): Promise<void>;
+}
+```
+
+Implement it directly, or use a ready-made adapter:
+[`@angadie/chittie-transport-web`](../chittie-transport-web) ·
+[`@angadie/chittie-transport-react-native`](../chittie-transport-react-native).
+
+## Helpers
+
+```ts
+import { print, writeBytes, chunk } from '@angadie/chittie-transport';
+
+// connect (if supported) then write:
+await print(transport, bytes);
+
+// write in fixed-size chunks (BLE MTU), with an optional inter-chunk delay:
+await writeBytes(transport, bytes, { chunkSize: 180, chunkDelayMs: 20 });
+
+// split bytes yourself:
+const parts = chunk(bytes, 180); // Uint8Array[]
+```
+
+`print` does not disconnect — the caller owns connection lifetime.
+
+## License
+
+MIT.

package/dist/index.d.mts

@@ -0,0 +1,31 @@
+//#region src/index.d.ts
+/**
+ * A transport ships ESC/POS bytes to a printer. Deliberately tiny and
+ * library-agnostic: discovery/permissions/connection details live in the
+ * concrete adapter (web / react-native / node); this is just the send contract.
+ */
+interface Transport {
+  /** Optional: open the connection (request port, connect BLE, open socket…). */
+  connect?(): Promise<void>;
+  /** Write raw bytes to the printer. The one required method. */
+  write(data: Uint8Array): Promise<void>;
+  /** Optional: close the connection. */
+  disconnect?(): Promise<void>;
+}
+/** Split bytes into fixed-size chunks (e.g. for a BLE MTU). */
+declare function chunk(data: Uint8Array, size: number): Uint8Array[];
+interface WriteOptions {
+  /** If set, write in chunks of this many bytes (BLE/serial buffer limits). */
+  chunkSize?: number;
+  /** Optional delay (ms) between chunks, for slow links. */
+  chunkDelayMs?: number;
+}
+/** Write bytes, optionally chunked with an inter-chunk delay. */
+declare function writeBytes(transport: Transport, data: Uint8Array, options?: WriteOptions): Promise<void>;
+/**
+ * Convenience: connect (if the transport supports it) then write the bytes.
+ * Does not disconnect — the caller owns connection lifetime.
+ */
+declare function print(transport: Transport, data: Uint8Array, options?: WriteOptions): Promise<void>;
+//#endregion
+export { Transport, WriteOptions, chunk, print, writeBytes };

package/dist/index.mjs

@@ -0,0 +1,31 @@
+//#region src/index.ts
+/** Split bytes into fixed-size chunks (e.g. for a BLE MTU). */
+function chunk(data, size) {
+	if (size <= 0) throw new RangeError("chunk size must be > 0");
+	const out = [];
+	for (let offset = 0; offset < data.length; offset += size) out.push(data.subarray(offset, Math.min(offset + size, data.length)));
+	return out;
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Write bytes, optionally chunked with an inter-chunk delay. */
+async function writeBytes(transport, data, options = {}) {
+	if (!options.chunkSize) {
+		await transport.write(data);
+		return;
+	}
+	const chunks = chunk(data, options.chunkSize);
+	for (let i = 0; i < chunks.length; i++) {
+		await transport.write(chunks[i]);
+		if (options.chunkDelayMs && i < chunks.length - 1) await delay(options.chunkDelayMs);
+	}
+}
+/**
+* Convenience: connect (if the transport supports it) then write the bytes.
+* Does not disconnect — the caller owns connection lifetime.
+*/
+async function print(transport, data, options = {}) {
+	if (transport.connect) await transport.connect();
+	await writeBytes(transport, data, options);
+}
+//#endregion
+export { chunk, print, writeBytes };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@angadie/chittie-transport",
+  "version": "0.1.0",
+  "description": "Transport contract for chittie: { connect; write; disconnect } + chunk()/writeBytes/print helpers. Zero runtime deps.",
+  "license": "MIT",
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx spikes/transport.spike.ts"
+  }
+}