@7365admin1/layer-common 3.2.1 → 3.2.2-staging.101

package/composables/useWebUsb.ts

@@ -11,6 +11,10 @@ interface USBDevice {
   close(): Promise<void>;
   selectConfiguration(configurationValue: number): Promise<void>;
   claimInterface(interfaceNumber: number): Promise<void>;
+  selectAlternateInterface(
+    interfaceNumber: number,
+    alternateSetting: number,
+  ): Promise<void>;
   releaseInterface(interfaceNumber: number): Promise<void>;
   transferOut(
     endpointNumber: number,
@@ -19,14 +23,27 @@ interface USBDevice {
   configuration: {
     interfaces: Array<{
       interfaceNumber: number;
+      alternate: USBAlternateInterface;
       alternates: Array<{
+        alternateSetting: number;
+        interfaceClass: number;
         endpoints: Array<{
           endpointNumber: number;
           direction: "in" | "out";
         }>;
       }>;
     }>;
-  };
+  } | null;
+  configurations: Array<{ configurationValue: number }>;
+}
+
+interface USBAlternateInterface {
+  alternateSetting: number;
+  interfaceClass: number;
+  endpoints: Array<{
+    endpointNumber: number;
+    direction: "in" | "out";
+  }>;
 }
 
 interface USBOutTransferResult {
@@ -39,13 +56,86 @@ declare global {
     usb: {
       getDevices(): Promise<USBDevice[]>;
       requestDevice(options: {
-        filters: Array<{ vendorId?: number; productId?: number }>;
+        filters: Array<{
+          vendorId?: number;
+          productId?: number;
+          classCode?: number;
+        }>;
       }): Promise<USBDevice>;
     };
   }
 }
 
 export default function useWebUsb() {
+  const printerConnections = new WeakMap<
+    USBDevice,
+    { interfaceNumber: number; endpointNumber: number }
+  >();
+
+  const protectedInterfaceClasses = new Set([0x01, 0x03, 0x08, 0x0b, 0x0e, 0x10, 0xe0]);
+
+  function getErrorMessage(error: unknown, fallback: string) {
+    return error instanceof Error && error.message ? error.message : fallback;
+  }
+
+  function findPrinterInterface(device: USBDevice) {
+    const candidates = (device.configuration?.interfaces || []).flatMap((usbInterface) =>
+      usbInterface.alternates.flatMap((alternate) => {
+        const outputEndpoint = alternate.endpoints.find((endpoint) => endpoint.direction === "out");
+        if (!outputEndpoint || protectedInterfaceClasses.has(alternate.interfaceClass)) return [];
+
+        return [{
+          interfaceNumber: usbInterface.interfaceNumber,
+          alternateSetting: alternate.alternateSetting,
+          activeAlternateSetting: usbInterface.alternate.alternateSetting,
+          interfaceClass: alternate.interfaceClass,
+          endpointNumber: outputEndpoint.endpointNumber,
+        }];
+      }),
+    );
+
+    candidates.sort((left, right) => {
+      const priority = (interfaceClass: number) => interfaceClass === 0x07 ? 0 : interfaceClass === 0xff ? 1 : 2;
+      return priority(left.interfaceClass) - priority(right.interfaceClass);
+    });
+
+    return candidates[0] || null;
+  }
+
+  async function preparePrinterDevice(device: USBDevice) {
+    await device.open();
+    if (!device.configuration) {
+      await device.selectConfiguration(device.configurations[0]?.configurationValue || 1);
+    }
+
+    const printerInterface = findPrinterInterface(device);
+    if (!printerInterface) {
+      throw new Error(
+        "The selected USB device is not a compatible printer. Select the receipt printer instead of a Bluetooth, camera, keyboard, or other system device.",
+      );
+    }
+
+    await device.claimInterface(printerInterface.interfaceNumber);
+    if (printerInterface.alternateSetting !== printerInterface.activeAlternateSetting) {
+      await device.selectAlternateInterface(
+        printerInterface.interfaceNumber,
+        printerInterface.alternateSetting,
+      );
+    }
+
+    printerConnections.set(device, {
+      interfaceNumber: printerInterface.interfaceNumber,
+      endpointNumber: printerInterface.endpointNumber,
+    });
+    return device;
+  }
+
+  function getPrinterConnection(device: USBDevice) {
+    const connection = printerConnections.get(device);
+    if (!connection) throw new Error("Printer interface is not connected");
+    return connection;
+  }
+
   const isWebUsbSupported = computed(() => {
     return typeof navigator !== "undefined" && "usb" in navigator;
   });
@@ -75,7 +165,9 @@ export default function useWebUsb() {
       throw new Error("Web USB is not supported in this browser");
     }
     try {
-      const device = await navigator.usb.requestDevice({ filters: [] });
+      const device = await navigator.usb.requestDevice({
+        filters: [{ classCode: 0x07 }, { classCode: 0xff }],
+      });
       return {
         vendorId: device.vendorId,
         productId: device.productId,
@@ -84,12 +176,12 @@ export default function useWebUsb() {
         serialNumber: device.serialNumber || "Unknown",
         deviceId: `${device.vendorId}:${device.productId}`,
       };
-    } catch (error: any) {
-      if (error.name === "NotFoundError") {
+    } catch (error: unknown) {
+      if (error instanceof DOMException && error.name === "NotFoundError") {
         throw new Error("No device selected");
       }
       console.error("Error requesting USB device:", error);
-      throw new Error("Failed to access USB device");
+      throw new Error(getErrorMessage(error, "Failed to access USB printer"));
     }
   };
 
@@ -110,14 +202,17 @@ export default function useWebUsb() {
         });
       }
       console.log("[WebUSB] Opening device:", device.vendorId, device.productId);
-      await device.open();
-      await device.selectConfiguration(1);
-      await device.claimInterface(0);
+      await preparePrinterDevice(device);
       console.log("[WebUSB] Device opened and interface claimed.");
       return device;
-    } catch (error) {
+    } catch (error: unknown) {
       console.error("Error connecting to USB device:", error);
-      throw new Error("Failed to connect to USB device");
+      try {
+        await device?.close();
+      } catch (closeError) {
+        console.error("Error closing rejected USB device:", closeError);
+      }
+      throw new Error(getErrorMessage(error, "Failed to connect to USB printer"));
     }
   };
 
@@ -173,15 +268,20 @@ export default function useWebUsb() {
           ? "Connection and print test successful"
           : "Connection successful but print test failed",
       };
-    } catch (error: any) {
+    } catch (error: unknown) {
       return {
         success: false,
-        error: error.message,
+        error: getErrorMessage(error, "Failed to connect to USB printer"),
         message: "Connection failed",
       };
     } finally {
       if (device) {
         try {
+          const connection = printerConnections.get(device);
+          if (connection) {
+            await device.releaseInterface(connection.interfaceNumber);
+            printerConnections.delete(device);
+          }
           await device.close();
         } catch (closeError) {
           console.error("Error closing device:", closeError);
@@ -205,21 +305,16 @@ export default function useWebUsb() {
       ];
 
       const testData = new Uint8Array(testCommands);
-      const usbInterface = device.configuration.interfaces[0];
-      const alternate = usbInterface.alternates[0];
-      const outputEndpoint = alternate.endpoints.find(
-        (ep: any) => ep.direction === "out",
-      );
-
-      if (!outputEndpoint) {
-        throw new Error("No output endpoint found");
-      }
-
-      await device.transferOut(outputEndpoint.endpointNumber, testData);
+      const { endpointNumber } = getPrinterConnection(device);
+      await device.transferOut(endpointNumber, testData);
       return { success: true, message: "Test print sent successfully" };
-    } catch (error: any) {
+    } catch (error: unknown) {
       console.error("Test print error:", error);
-      return { success: false, error: error.message, message: "Test print failed" };
+      return {
+        success: false,
+        error: getErrorMessage(error, "Test print failed"),
+        message: "Test print failed",
+      };
     }
   };
 
@@ -354,13 +449,8 @@ export default function useWebUsb() {
   ) => {
     try {
       console.log("[WebUSB] printQrCode start — doorLevel:", doorLevel, "liftLevel:", liftLevel, "company:", companyName, "address:", address);
-      const usbInterface = device.configuration.interfaces[0];
-      const alternate = usbInterface.alternates[0];
-      const outputEndpoint = alternate.endpoints.find(
-        (ep: any) => ep.direction === "out",
-      );
-      if (!outputEndpoint) throw new Error("No output endpoint found");
-      console.log("[WebUSB] Using endpoint:", outputEndpoint.endpointNumber);
+      const { endpointNumber } = getPrinterConnection(device);
+      console.log("[WebUSB] Using endpoint:", endpointNumber);
 
       const canvas = await createReceiptLayout(
         urlImage,
@@ -375,17 +465,17 @@ export default function useWebUsb() {
       const rasterData = canvasToRaster(canvas);
       console.log("[WebUSB] Raster data size:", rasterData.byteLength, "bytes");
 
-      await device.transferOut(outputEndpoint.endpointNumber, rasterData.buffer);
+      await device.transferOut(endpointNumber, rasterData.buffer);
       console.log("[WebUSB] Raster data sent.");
 
       const CUT = new Uint8Array([0x1d, 0x56, 0x41, 0x10]);
-      await device.transferOut(outputEndpoint.endpointNumber, CUT.buffer);
+      await device.transferOut(endpointNumber, CUT.buffer);
       console.log("[WebUSB] Cut command sent.");
 
       return { success: true, message: "QR print sent successfully" };
-    } catch (error: any) {
+    } catch (error: unknown) {
       console.error("[WebUSB] printQrCode error:", error);
-      return { success: false, error: error.message };
+      return { success: false, error: getErrorMessage(error, "Unable to print QR code") };
     }
   };
 

package/nuxt.config.ts

@@ -7,6 +7,37 @@ export default defineNuxtConfig({
     transpile: ["vuetify"],
   },
 
+  /**
+   * THE REDESIGN'S TYPEFACE - LOADED, DELIBERATELY NOT APPLIED YET.
+   *
+   * `--font-sans` in `assets/css/tokens.css` names Manrope, and a token that
+   * names a font nobody loaded is a trap: the next phase writes
+   * `font-family: var(--font-sans)`, silently falls back to Arial, and looks
+   * fine to whoever wrote it. So the stylesheet is requested here.
+   *
+   * Nothing sets `font-family` on the page in Phase 1. Switching eleven
+   * applications to a new typeface before one screen has been rebuilt would
+   * leave the whole product looking half-migrated; each phase adopts the token
+   * as it rebuilds its own surfaces. Browsers do not download a webfont no
+   * element uses, so until then this costs one small CSS request.
+   */
+  app: {
+    head: {
+      link: [
+        { rel: "preconnect", href: "https://fonts.googleapis.com" },
+        {
+          rel: "preconnect",
+          href: "https://fonts.gstatic.com",
+          crossorigin: "",
+        },
+        {
+          rel: "stylesheet",
+          href: "https://fonts.googleapis.com/css2?family=Manrope:wght@400;500;600;700;800&family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200&display=swap",
+        },
+      ],
+    },
+  },
+
   runtimeConfig: {
     public: {
       cookieConfig: {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "3.2.1",
+  "version": "3.2.2-staging.101",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "publishConfig": {
@@ -14,6 +14,8 @@
     "build": "nuxt build .playground",
     "generate": "nuxt generate .playground",
     "preview": "nuxt preview .playground",
+    "test": "esbuild composables/useVisitorSocket.ts --format=esm --outfile=test/.build/useVisitorSocket.mjs --log-level=error && node --test \"test/*.test.mjs\" && yarn test:units",
+    "test:units": "node --experimental-strip-types --test \"utils/*.test.ts\"",
     "release": "yarn run build && changeset publish"
   },
   "devDependencies": {
@@ -40,6 +42,7 @@
     "qrcode": "^1.5.4",
     "qrcode.vue": "^3.4.1",
     "sass": "^1.80.6",
+    "sip.js": "0.21.2",
     "socket.io-client": "^4.8.3",
     "vue-draggable-next": "^2.3.0",
     "vue3-signature": "^0.2.4",

package/pages/[org]/[site]/access-mgmt/intercom/index.vue

@@ -5,7 +5,7 @@
       :org="orgId"
       message="Enable HID as a service for this site before configuring HID intercom."
     >
-      <HidIntercomManagement :site="siteId" />
+      <HidIntercomManagement :site="siteId" :org="orgId" />
     </HidEnabledGate>
   </v-container>
 </template>

package/pages/notification-settings.vue

@@ -0,0 +1,19 @@
+<template>
+  <NotificationSettings />
+</template>
+
+<script setup lang="ts">
+/**
+ * Notification settings, reachable from Profile.
+ *
+ * The page lives in the shared layer so every web app has the route and there
+ * is only one screen to keep correct; the link to it sits in Profile, in the
+ * account app, which is where "Manage Account" already sends everybody.
+ */
+definePageMeta({
+  middleware: ["01-auth"],
+});
+
+const { authenticate } = useLocalAuth();
+authenticate();
+</script>

package/plugins/secure-member.client.ts

@@ -12,75 +12,40 @@ export default defineNuxtPlugin(() => {
 
   const { userAppRole, id, orgNature } = useLocalSetup();
 
-  router.afterEach(async (to) => {
+  router.beforeEach(async (to) => {
     const isMember = to.meta?.memberOnly;
 
     if (!isMember) return;
 
     const APP = useRuntimeConfig().public.APP;
-    const org = computed(
-      () =>
-        (to.params.org as string) || (to.params.organization as string) || ""
-    );
+    const org =
+      (to.params.org as string) || (to.params.organization as string) || "";
 
-    console.log('[secure-member-plugin', 'org', org.value)
-
-    if (!hexSchema.safeParse(org.value).success) {
-      return router.replace({ name: "require-organization-membership" });
+    if (!hexSchema.safeParse(org).success) {
+      return { name: "require-organization-membership" };
     }
 
-    const userId = computed(() => useCookie("user").value ?? "");
-
-    const { data: userMemberData, error: userMemberError } =
-      await useLazyAsyncData(
-        "plugin-get-member-by-id-" + userId.value + "-" + APP + "-" + org.value,
-        () => getByUserType(userId.value, APP, org.value),
-        { watch: [userId] }
-      );
-
-    watchEffect(() => {
-      if (userMemberError.value) {
-        console.log('running-secure-member-redirect-plugin')
-        navigateTo(
-          {
-            name: "index",
-          },
-          { replace: true }
-        );
-      }
-    });
-
-    const roleId = ref("roleId");
+    const userId = useCookie("user").value ?? "";
+    if (!userId) return { name: "index" };
 
-    watchEffect(() => {
-      if (userMemberData.value) {
-        id.value = userMemberData.value.org ?? "";
-        roleId.value = userMemberData.value.role ?? "roleId";
-      }
-    });
+    try {
+      const userMemberData = await getByUserType(userId, APP, org);
+      id.value = userMemberData.org ?? "";
 
-    const { data: getOrgByIdReq } = await useLazyAsyncData(
-      "plugin-get-org-by-id-" + org.value,
-      () => getById(org.value),
-      { watch: [org] }
-    );
+      const [orgResult, roleResult] = await Promise.allSettled([
+        getById(org),
+        userMemberData.role ? getRoleById(userMemberData.role) : null,
+      ]);
 
-    watchEffect(() => {
-      if (getOrgByIdReq.value) {
-        orgNature.value = getOrgByIdReq.value.nature ?? "";
+      if (orgResult.status === "fulfilled" && orgResult.value) {
+        orgNature.value = orgResult.value.nature ?? "";
       }
-    });
 
-    const { data: getRoleByIdReq } = await useLazyAsyncData(
-      "plugin-get-role-by-id-" + roleId.value,
-      () => getRoleById(roleId.value),
-      { watch: [roleId] }
-    );
-
-    watchEffect(() => {
-      if (getRoleByIdReq.value) {
-        userAppRole.value = getRoleByIdReq.value;
+      if (roleResult.status === "fulfilled" && roleResult.value) {
+        userAppRole.value = roleResult.value;
       }
-    });
+    } catch (error) {
+      return { name: "index" };
+    }
   });
 });

package/plugins/vuetify.ts

@@ -42,7 +42,40 @@ import {
 } from "vuetify-pro-tiptap";
 import "vuetify-pro-tiptap/style.css";
 
+import { LIGHT_THEME, DARK_THEME } from "../utils/theme";
+import { THEME_COOKIE } from "../composables/useThemePreference";
+import type { CookieOptions } from "#app";
+
+/**
+ * The design tokens. Loaded HERE rather than in `nuxt.config.ts` so they land
+ * after `vuetify/styles` in the bundle - `tokens.css` aliases `--v-theme-*`,
+ * which Vuetify has to have emitted first.
+ */
+import "../assets/css/tokens.css";
+import "../assets/css/shell.css";
+import "../assets/css/screens.css";
+import "../assets/css/primitives.css";
+
 export default defineNuxtPlugin((app) => {
+  /**
+   * BOOT ON THE REMEMBERED THEME, DON'T CORRECT IT AFTERWARDS.
+   *
+   * Reading the cookie here, before `createVuetify`, is what makes the choice
+   * survive a reload with no flash: Vuetify's first paint is already the right
+   * theme, so there is no moment where the wrong one is on screen. Setting it
+   * from a component's `onMounted` would repaint the whole application one
+   * frame in, which is the flash this is written to avoid.
+   *
+   * `useThemePreference()` writes this cookie; nothing else does.
+   */
+  const stored = useCookie<string | null>(
+    THEME_COOKIE,
+    // typed `unknown` in runtimeConfig; same object `sid` and `user` use
+    useRuntimeConfig().public.cookieConfig as CookieOptions<string | null> & {
+      readonly?: false;
+    }
+  ).value;
+
   const vuetify = createVuetify({
     defaults: {
       VTextField: {
@@ -69,17 +102,43 @@ export default defineNuxtPlugin((app) => {
       //   hint: "This field is required",
       // },
     },
+    /**
+     * THE PRODUCT HAS TWO THEMES, AND UNTIL NOW ONLY ONE OF THEM WAS OURS.
+     *
+     * Every app shows a light/dark toggle in the app bar (Layout/Header.vue),
+     * and it sets Vuetify's built-in "light" and "dark" themes. Those were left
+     * at Vuetify's factory values, so one click on any screen in any of the
+     * eleven apps threw the brand away: `primary` stopped being the Seven365
+     * navy and became Material blue #2196F3 - and `primary` is the navigation
+     * drawer's fill - while `primary-button` and `text-primary`, used in around
+     * eighty places across the layer and the apps, do not exist in a stock
+     * theme at all, so those components lost their colour to an undefined CSS
+     * variable. There was also no way back to the brand: the toggle only ever
+     * flipped between the two stock themes.
+     *
+     * The fix is to make the stock names OURS rather than to add new names.
+     * Several components already branch on `theme.global.name === "dark"` (this
+     * layer's FormDialog, property-management's facility icons), so a
+     * differently-named dark theme would have left every one of them silently
+     * on their light branch inside a dark app. Overriding `light` and `dark`
+     * means the toggle, `v-theme-provider theme="light"`, the `plain-dark`
+     * layout and all of those comparisons keep working, and start being right.
+     *
+     * The colours themselves, and every ratio they were chosen for, are in
+     * `utils/theme.ts`, which `utils/theme.test.ts` measures on every run.
+     */
     theme: {
-      defaultTheme: "iservice365",
+      defaultTheme: stored === "dark" ? "dark" : "light",
       themes: {
-        iservice365: {
-          dark: false,
-          colors: {
-            primary: "#042134",
-            "primary-button": "#1867C0",
-            "text-primary": "#052439",
-          },
-        },
+        light: LIGHT_THEME,
+        dark: DARK_THEME,
+        /**
+         * The name this product booted on before the two above carried the
+         * brand. Kept, and identical to `light`, so anything that asks for it
+         * by name - in an app that is not in this repository - still gets a
+         * theme rather than a blank one.
+         */
+        iservice365: LIGHT_THEME,
       },
     },
     icons: {

package/test/visitor-socket.test.mjs

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { cameraAlertMessage } from "./.build/useVisitorSocket.mjs";
+
+/*
+ * The reported symptom was one camera raising a red toast every 10 seconds on
+ * an unrelated page. API-core now paces the alert; this side has to make sure
+ * several cameras failing at once still cannot become several snackbars.
+ */
+
+test("nothing is shown when no camera is down", () => {
+  assert.equal(cameraAlertMessage([]), "");
+});
+
+test("one failing camera shows the server's own message, which names it", () => {
+  const text = "The entry and exit ANPR camera at Seventh Condominium is not responding.";
+  assert.equal(cameraAlertMessage([text]), text);
+});
+
+test("several failing cameras collapse into a single line", () => {
+  const many = ["camera one is down", "camera two is down", "camera three is down"];
+  const text = cameraAlertMessage(many);
+  assert.match(text, /^3 cameras at this site are not responding/);
+  for (const message of many) assert.doesNotMatch(text, new RegExp(message));
+});
+
+test("the collapsed line points at the page that lists them", () => {
+  assert.match(cameraAlertMessage(["a", "b"]), /Site Settings > Cameras/);
+});
+
+test("no camera message tells the operator to deactivate anything", () => {
+  for (const messages of [["a camera is down"], ["a", "b"]]) {
+    assert.doesNotMatch(cameraAlertMessage(messages), /inactive|deactivat/i);
+  }
+});

package/types/org.d.ts

@@ -11,4 +11,6 @@ declare type TOrg = {
   status?: string;
   deletedAt?: string;
   nature?: string;
+  terms?: string;
+  policies?: string;
 };

package/types/site.d.ts

@@ -1,5 +1,76 @@
 declare type TSiteCreate = Pick<TSite, "name" | "description" | "orgId">;
 
+declare type THidQrCodeFormat = "0" | "1" | "2";
+
+declare type THidPermissionCategory =
+  | "resident"
+  | "property_management"
+  | "service_provider";
+
+declare type THidPermissionAssignment = {
+  subjectId: string;
+  category: THidPermissionCategory;
+  name: string;
+  subtitle?: string;
+  intercom: boolean;
+  readerId?: string;
+  location?: string;
+  locationKey?: string;
+};
+
+declare type THidSitePermissions = {
+  orgId: string;
+  site: string;
+  readerId: string;
+  location: string;
+  assignments: THidPermissionAssignment[];
+  counts: {
+    resident: number;
+    propertyManagement: number;
+    serviceProvider: number;
+    intercom: number;
+  };
+};
+
+declare type THidPermissionCandidate = THidPermissionAssignment & {
+  selected: boolean;
+};
+
+declare type THidQrCodePassConfig = {
+  enabled: boolean;
+  onlineMode?: boolean;
+  readerId: string;
+  qrFormat: THidQrCodeFormat;
+  identificationMethods?: {
+    facial: boolean;
+    card: boolean;
+    qrCode: boolean;
+    idPassword: boolean;
+    pin: boolean;
+    bluetooth: boolean;
+  };
+  printer: {
+    vendorId: string;
+    productId: string;
+  };
+  template: {
+    header: string;
+    subtext: string;
+  };
+  validityMinutes: number | null;
+  updatedAt?: string;
+};
+
+declare type TSiteMetadata = {
+  block?: number;
+  guardPosts?: number;
+  gracePeriod?: number;
+  incidentCounter?: number;
+  incidentLogo?: string;
+  services?: Record<string, unknown>[];
+  hidQrCodePass?: THidQrCodePassConfig;
+};
+
 
 declare type TSite = {
   _id?: string;