@homebridge-plugins/homebridge-printer 0.0.0-stage → 1.0.0

package/lib/fakegato/fakegato-storage.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+const hostname = os.hostname().split('.')[0]
+
+/**
+ * Path separators, as the platform actually understands them.
+ *
+ * A history file is named after the accessory, and an accessory is named by
+ * whoever set the device up. A name carrying a separator stops being a name
+ * once it reaches `path.join`: it reads as a directory that does not exist, so
+ * the write fails with ENOENT and - because nothing here passes a callback -
+ * the error goes nowhere. A device called "Kitchen/Diner" simply never saved
+ * its history, with nothing in the log to say so. HAP-NodeJS guards its own
+ * storage keys against the same thing.
+ *
+ * Only genuine separators are replaced, and only where they are one. A
+ * backslash is an ordinary filename character on Linux, so replacing it there
+ * would rename the file of anyone already using one and lose their history.
+ */
+const PATH_SEPARATORS = process.platform === 'win32'
+  ? /[\\/]/g
+  : /\//g
+
+function toFileNamePart(name) {
+  return String(name ?? '').replace(PATH_SEPARATORS, '-')
+}
+
+export default class {
+  constructor(params) {
+    if (!params) {
+      params = {}
+    }
+    this.writers = []
+    this.log = params.log || {}
+    if (!this.log) {
+      this.log = () => {}
+    }
+    this.addingWriter = false
+  }
+
+  addWriter(service, params) {
+    if (!this.addingWriter) {
+      this.addingWriter = true
+      if (!params) {
+        params = {}
+      }
+      this.log('[%s] FGS addWriter().', service.accessoryName)
+      const newWriter = {
+        service,
+        callback: params.callback,
+        fileName: `${hostname}_${toFileNamePart(service.accessoryName)}_persist.json`,
+      }
+      const onReady = typeof params.onReady === 'function'
+        ? params.onReady
+        : () => {}
+      newWriter.storageHandler = fs
+      newWriter.path = params.path || path.join(os.homedir(), '.homebridge')
+      this.writers.push(newWriter)
+      this.addingWriter = false
+      onReady()
+    } else {
+      setTimeout(() => this.addWriter(service, params), 100)
+    }
+  }
+
+  getWriter(service) {
+    return this.writers.find(ele => ele.service === service)
+  }
+
+  _getWriterIndex(service) {
+    return this.writers.findIndex(ele => ele.service === service)
+  }
+
+  getWriters() {
+    return this.writers
+  }
+
+  delWriter(service) {
+    const index = this._getWriterIndex(service)
+    this.writers.splice(index, 1)
+  }
+
+  write(params) {
+    if (!this.writing) {
+      this.writing = true
+      const writer = this.getWriter(params.service)
+      const callBack = typeof params.callback === 'function'
+        ? params.callback
+        : typeof writer.callback === 'function'
+          ? writer.callback
+          : () => {}
+      const fileLoc = path.join(writer.path, writer.fileName)
+      // Written to a temporary file and renamed over the target, so a write cut
+      // short by a restart or a power cut leaves the previous history intact
+      // rather than a half-written file that will not parse.
+      //
+      // The leading dot matters: this is HAP-NodeJS's persist directory, and it
+      // reads every file that does not start with one into memory at startup -
+      // so a temporary file left behind by a crash would be loaded, and kept,
+      // for the life of every run after it. The pid keeps child bridges sharing
+      // the directory from racing on the same temporary name.
+      const tempLoc = path.join(writer.path, `.${writer.fileName}.${process.pid}.tmp`)
+      this.log(
+        '[%s] FGS write file [%s] [%s].',
+        params.service.accessoryName,
+        fileLoc,
+        params.data.substring(1, 81),
+      )
+      writer.storageHandler.writeFile(tempLoc, params.data, 'utf8', (writeErr) => {
+        if (writeErr) {
+          // the temporary file may never have been created, so a failure to
+          // remove it is not worth reporting over the write error itself
+          writer.storageHandler.unlink(tempLoc, () => {
+            this.writing = false
+            callBack(writeErr)
+          })
+          return
+        }
+        writer.storageHandler.rename(tempLoc, fileLoc, (renameErr) => {
+          this.writing = false
+          callBack(renameErr || null)
+        })
+      })
+    } else {
+      setTimeout(() => this.write(params), 100)
+    }
+  }
+
+  read(params) {
+    const writer = this.getWriter(params.service)
+    const callBack = typeof params.callback === 'function'
+      ? params.callback
+      : typeof writer.callback === 'function'
+        ? writer.callback
+        : () => {}
+    const fileLoc = path.join(writer.path, writer.fileName)
+    this.log('[%s] FGS read file [%s].', params.service.accessoryName, fileLoc)
+    writer.storageHandler.readFile(fileLoc, 'utf8', callBack)
+  }
+
+  remove(params) {
+    const writer = this.getWriter(params.service)
+    const callBack = typeof params.callback === 'function'
+      ? params.callback
+      : typeof writer.callback === 'function'
+        ? writer.callback
+        : () => {}
+    const fileLoc = path.join(writer.path, writer.fileName)
+    this.log('[%s] FGS delete file [%s].', params.service.accessoryName, fileLoc)
+    writer.storageHandler.unlink(fileLoc, callBack)
+  }
+}

package/lib/fakegato/fakegato-timer.js

@@ -0,0 +1,128 @@
+export default class {
+  constructor(params) {
+    if (!params) {
+      params = {}
+    }
+    this.subscribedServices = []
+    this.minutes = params.minutes || 10
+    this.intervalID = null
+    this.running = false
+    this.log = params.log || {}
+    if (!this.log) {
+      this.log = () => {}
+    }
+  }
+
+  subscribe(service, callback) {
+    this.log('[%s] FGT new subscription.', service.accessoryName)
+    const newService = {
+      service,
+      callback,
+      backLog: [],
+      previousBackLog: [],
+      previousAvrg: {},
+    }
+    this.subscribedServices.push(newService)
+  }
+
+  getSubscriber(service) {
+    return this.subscribedServices.find(el => el.service === service)
+  }
+
+  _getSubscriberIndex(service) {
+    return this.subscribedServices.findIndex(el => el.service === service)
+  }
+
+  getSubscribers() {
+    return this.subscribedServices
+  }
+
+  unsubscribe(service) {
+    const index = this._getSubscriberIndex(service)
+    if (index !== -1) {
+      this.subscribedServices.splice(index, 1)
+    }
+    if (this.subscribedServices.length === 0 && this.running) {
+      this.stop()
+    }
+  }
+
+  start() {
+    this.log('Starting global FGT [%s minutes].', this.minutes)
+    if (this.running) {
+      this.stop()
+    }
+    this.running = true
+    this.intervalID = setInterval(this.executeCallbacks.bind(this), this.minutes * 60 * 1000)
+  }
+
+  stop() {
+    this.log('Stopping global FGT.')
+    clearInterval(this.intervalID)
+    this.running = false
+    this.intervalID = null
+  }
+
+  executeCallbacks() {
+    this.log('FGT executeCallbacks().')
+    if (this.subscribedServices.length !== 0) {
+      for (const s in this.subscribedServices) {
+        if (Object.hasOwn(this.subscribedServices, s)) {
+          const service = this.subscribedServices[s]
+          if (typeof service.callback === 'function') {
+            service.previousAvrg = service.callback({
+              backLog: service.backLog,
+              previousAvrg: service.previousAvrg,
+              timer: this,
+              immediate: false,
+            })
+          }
+        }
+      }
+    }
+  }
+
+  executeImmediateCallback(service) {
+    this.log('[%s] FGT executeImmediateCallback().', service.accessoryName)
+    if (typeof service.callback === 'function' && service.backLog.length) {
+      service.previousAvrg = service.callback({
+        backLog: service.backLog,
+        previousAvrg: service.previousAvrg,
+        timer: this,
+        immediate: true,
+      })
+    }
+  }
+
+  addData(params) {
+    const data = params.entry
+    const { service } = params
+    const immediateCallback = params.immediateCallback || false
+    this.log(
+      '[%s] FGT addData() [%s] immediate [%s].',
+      service.accessoryName,
+      data,
+      immediateCallback,
+    )
+    if (immediateCallback) {
+      this.getSubscriber(service).backLog[0] = data
+    } else {
+      this.getSubscriber(service).backLog.push(data)
+    }
+    if (immediateCallback) {
+      this.executeImmediateCallback(this.getSubscriber(service))
+    }
+    if (!this.running) {
+      this.start()
+    }
+  }
+
+  emptyData(service) {
+    this.log('[%s] FGT emptyData().', service.accessoryName)
+    const source = this.getSubscriber(service)
+    if (source.backLog.length) {
+      source.previousBackLog = source.backLog
+    }
+    source.backLog = []
+  }
+}

package/lib/fakegato/uuid.js

@@ -0,0 +1,28 @@
+// https://github.com/homebridge/HAP-NodeJS/blob/master/src/lib/util/uuid.ts
+
+const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const shortRegex = /^[0-9a-f]{1,8}$/i
+
+function isValid(UUID) {
+  return uuidRegex.test(UUID)
+}
+
+function toLongFormUUID(uuid, base = '-0000-1000-8000-0026BB765291') {
+  if (isValid(uuid)) {
+    return uuid.toUpperCase()
+  }
+  if (!shortRegex.test(uuid)) {
+    throw new TypeError('uuid was not a valid UUID or short form UUID')
+  }
+  if (!isValid(`00000000${base}`)) {
+    throw new TypeError('base was not a valid base UUID')
+  }
+  return ((`00000000${uuid}`).slice(-8) + base).toUpperCase()
+}
+
+function toShortFormUUID(uuid, base = '-0000-1000-8000-0026BB765291') {
+  uuid = toLongFormUUID(uuid, base)
+  return uuid.substring(0, 8)
+}
+
+export { toLongFormUUID, toShortFormUUID }

package/lib/homebridge-ui/public/dashboard.css

@@ -0,0 +1,207 @@
+/* Printer dashboard */
+.hp-dashboard {
+  --bg: #e3e3ee;
+  --card: transparent;
+  --text: #1f1f2b;
+  --model: #4b55e6;
+  --muted: #6f6f80;
+  --box: #f3f3f8;
+  --tube-bg: #e1e1e8;
+  --tube-edge: #d2d2dc;
+  --low: #f08a00;
+  --pill-bg: #f7f7fb;
+  --pill-border: #2a2a36;
+  --ok: #1f8a4c;
+  --printing: #4b55e6;
+  --error: #c62f2f;
+
+  /* printer illustration */
+  --body-hi: #ffffff;
+  --body-mid: #eef0f4;
+  --body-lo: #dfe2e8;
+  --accent-band: #7f97c6;
+  --line: #c3c7d1;
+  --shadow: rgba(40, 40, 70, 0.10);
+  --paper: #ffffff;
+  --panel: #9aa9c9;
+  --panel-screen: #53607b;
+  --plate: #f7f8fa;
+  --opening: #f4f5f8;
+  --rollers: #3a3d46;
+  --slot: #5b5f6b;
+  --tray: #f2f3f6;
+  --logo: #8ea1cb;
+  --ink-lines: #a9b1c8;
+
+  font-family: "Inter", "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Arial, sans-serif;
+  color: var(--text);
+  background: var(--bg);
+  border-radius: 14px;
+  padding: 8px 0;
+  -webkit-font-smoothing: antialiased;
+}
+
+.hp-dashboard.hp-dark,
+body.dark-mode .hp-dashboard {
+  --bg: #1d1d27;
+  --text: #ececf4;
+  --model: #8d95ff;
+  --muted: #a3a3b6;
+  --box: #282836;
+  --tube-bg: #3a3a4a;
+  --tube-edge: #4a4a5c;
+  --pill-bg: #262634;
+  --pill-border: #9a9ab0;
+  --body-hi: #f4f5f8;
+  --body-mid: #e2e5ea;
+  --body-lo: #cdd1d9;
+  --shadow: rgba(0, 0, 0, 0.35);
+}
+
+.hp-dashboard * { box-sizing: border-box; }
+
+.hp-card {
+  display: grid;
+  grid-template-columns: minmax(260px, 1fr) minmax(260px, 1.35fr);
+  align-items: center;
+  gap: 24px;
+  padding: 32px 40px;
+}
+.hp-card + .hp-card { border-top: 1px solid var(--tube-edge); }
+
+.hp-name {
+  font-size: clamp(36px, 6vw, 64px);
+  font-weight: 500;
+  letter-spacing: -0.02em;
+  line-height: 1.05;
+  margin: 0 0 8px;
+}
+.hp-model {
+  color: var(--model);
+  font-size: clamp(18px, 2.4vw, 28px);
+  line-height: 1.3;
+  margin-bottom: 26px;
+  max-width: 18em;
+}
+
+.hp-supplies {
+  display: inline-block;
+  background: var(--box);
+  border-radius: 14px;
+  padding: 18px 20px 16px;
+  min-width: 240px;
+}
+.hp-inks { display: flex; gap: 18px; margin-bottom: 12px; align-items: flex-start; }
+.hp-ink { display: flex; flex-direction: column; align-items: center; gap: 8px; }
+
+.hp-tube {
+  display: flex;
+  gap: 2px;
+  height: 124px;
+  border-radius: 999px;
+  overflow: hidden;
+  padding: 0;
+  background: var(--tube-bg);
+  box-shadow: inset 0 0 0 1px var(--tube-edge);
+}
+.hp-tube.is-low { box-shadow: 0 0 0 2px var(--low); }
+.hp-tube.is-unknown .hp-fill { opacity: .45; }
+
+.hp-stripe {
+  width: 11px;
+  height: 100%;
+  position: relative;
+  background: linear-gradient(90deg, rgba(255,255,255,.55), rgba(255,255,255,.15));
+}
+.hp-tube > .hp-stripe:only-child { width: 34px; }
+.hp-fill {
+  position: absolute;
+  left: 0; right: 0; bottom: 0;
+  background: linear-gradient(180deg, color-mix(in srgb, var(--ink) 15%, transparent) 0%, var(--ink) 45%, var(--ink) 100%);
+  transition: height .8s cubic-bezier(.2,.7,.2,1);
+}
+
+.hp-dots { position: relative; width: 22px; height: 18px; }
+.hp-dot { position: absolute; width: 9px; height: 9px; border-radius: 50%; }
+.hp-dots-1 .hp-dot { left: 6px; top: 4px; }
+.hp-dots-2 .hp-dot:nth-child(1) { left: 1px; top: 4px; }
+.hp-dots-2 .hp-dot:nth-child(2) { left: 12px; top: 4px; }
+.hp-dots-3 .hp-dot:nth-child(1) { left: 6px; top: 0; }
+.hp-dots-3 .hp-dot:nth-child(2) { left: 0; top: 9px; }
+.hp-dots-3 .hp-dot:nth-child(3) { left: 11px; top: 9px; }
+
+.hp-pct { font-size: 12px; color: var(--muted); font-variant-numeric: tabular-nums; }
+.hp-pct.is-low { color: var(--low); font-weight: 600; }
+
+.hp-meta { color: var(--muted); font-size: 14px; line-height: 1.7; }
+.hp-warn { color: var(--low); font-size: 14px; font-weight: 600; margin-top: 4px; }
+
+.hp-pill {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-top: 16px;
+  padding: 10px 18px;
+  border: 1.5px solid var(--pill-border);
+  border-radius: 22px;
+  background: var(--pill-bg);
+  width: fit-content;
+  max-width: 340px;
+  line-height: 1.25;
+  font-size: 15px;
+}
+.hp-pill-icon { width: 28px; height: 28px; flex: none; color: var(--muted); }
+.hp-pill-icon svg { width: 100%; height: 100%; display: block; }
+.hp-pill-text span { color: var(--muted); }
+.is-ready .hp-pill-icon { color: var(--ok); }
+.is-printing .hp-pill-icon { color: var(--printing); animation: hp-pulse 1.4s ease-in-out infinite; }
+.is-printing .hp-pill { border-color: var(--printing); }
+.is-error .hp-pill-icon { color: var(--error); }
+.is-warn .hp-pill-icon { color: var(--low); }
+.is-warn .hp-pill { border-color: var(--low); }
+.is-warn .hp-led { fill: #ffb43d; animation: hp-blink 1.2s steps(2) infinite; }
+.is-error .hp-pill { border-color: var(--error); }
+.is-offline .hp-pill-icon { color: var(--text); }
+
+.hp-right { display: flex; justify-content: center; }
+.hp-printer-svg { width: 100%; max-width: 620px; height: auto; overflow: visible; }
+.is-offline .hp-printer-svg { filter: grayscale(.6); opacity: .75; }
+
+.hp-sheet { transform: translateY(-60px); }
+.is-printing .hp-sheet { animation: hp-feed 3.2s cubic-bezier(.45,.05,.4,1) infinite; }
+.hp-led { fill: #9aa3b5; }
+.is-ready .hp-led { fill: #46d17d; }
+.is-printing .hp-led { fill: #7c86ff; animation: hp-blink 1s steps(2) infinite; }
+.is-error .hp-led { fill: #ff5a4f; animation: hp-blink .8s steps(2) infinite; }
+
+@keyframes hp-feed {
+  0% { transform: translateY(-62px); }
+  70% { transform: translateY(14px); }
+  100% { transform: translateY(14px); opacity: 0; }
+}
+@keyframes hp-blink { 50% { opacity: .25; } }
+@keyframes hp-pulse { 50% { transform: scale(.9); opacity: .7; } }
+
+@media (prefers-reduced-motion: reduce) {
+  .is-printing .hp-sheet { animation: none; transform: translateY(0); }
+  .hp-led, .hp-pill-icon { animation: none !important; }
+}
+
+.hp-loading { padding: 40px; color: var(--muted); }
+.hp-empty { grid-template-columns: 1fr; }
+
+@media (max-width: 760px) {
+  .hp-card { grid-template-columns: 1fr; padding: 24px 16px; }
+  .hp-right { order: -1; }
+  .hp-printer-svg { max-width: 420px; }
+}
+
+.hp-dashboard.hp-dark .hp-dot,
+body.dark-mode .hp-dashboard .hp-dot { box-shadow: 0 0 0 1.5px rgba(255, 255, 255, 0.35); }
+
+/* Keep host themes (Homebridge UI / Bootstrap) from restyling the dashboard */
+.hp-dashboard .hp-name { color: var(--text); font-family: inherit; }
+.hp-dashboard .hp-model { color: var(--model); }
+
+.hp-energy { margin-top: 12px; font-size: 14px; color: var(--muted); font-variant-numeric: tabular-nums; }
+.hp-energy strong { color: var(--text); font-weight: 600; }

package/lib/homebridge-ui/public/dashboard.html

@@ -0,0 +1,33 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Printers</title>
+  <link rel="stylesheet" href="dashboard.css">
+  <style>
+    html, body { margin: 0; min-height: 100%; background: #e3e3ee; }
+    html.dark, html.dark body { background: #1d1d27; }
+    .page { max-width: 1280px; margin: 0 auto; padding: 24px 16px; }
+    .page .hp-dashboard { background: transparent; }
+  </style>
+</head>
+<body>
+  <main class="page"><div id="app"></div></main>
+  <script src="dashboard.js"></script>
+  <script>
+    (function () {
+      var app = document.getElementById('app');
+      var dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)');
+      function theme() {
+        var on = dark && dark.matches;
+        app.classList.toggle('hp-dark', !!on);
+        document.documentElement.classList.toggle('dark', !!on);
+      }
+      theme();
+      if (dark && dark.addEventListener) dark.addEventListener('change', theme);
+      HPDashboard.mount(app, HPDashboard.httpSource(''));
+    })();
+  </script>
+</body>
+</html>