@gelabs/ovr 0.2.1 → 0.3.0

package/dist/chunk-YGYA7KEG.js

@@ -0,0 +1,423 @@
+import { makeOvrTicketNo, addDays, makeBillNo, makeOrderOfPaymentNo, enrich, fullName } from './chunk-BI4EGLPG.js';
+import Dexie from 'dexie';
+import { useState, useEffect } from 'react';
+import { useLiveQuery } from 'dexie-react-hooks';
+
+var db = new Dexie("eovr-offline");
+db.version(1).stores({
+  tickets: "ovrTicketNo, paymentStatus, createdAt",
+  catalog: "code, category",
+  officers: "id",
+  meta: "key"
+});
+db.version(2).stores({
+  outbox: "ovrTicketNo, status, createdAt"
+});
+async function getMeta(key) {
+  const row = await db.meta.get(key);
+  return row?.value;
+}
+async function setMeta(key, value) {
+  await db.meta.put({ key, value });
+}
+
+// ../ovr-offline/src/sync.ts
+var API = "/api";
+var LEASE_MIN = 10;
+var LEASE_BATCH = 50;
+function setOfflineApiBase(base) {
+  API = base.replace(/\/$/, "");
+}
+function offlineApiBase() {
+  return API;
+}
+var SessionExpired = class extends Error {
+  constructor() {
+    super("session_expired");
+    this.name = "SessionExpired";
+  }
+};
+function isOnline() {
+  return typeof navigator !== "undefined" ? navigator.onLine : true;
+}
+async function call(path, init) {
+  let res;
+  try {
+    res = await fetch(`${API}${path}`, { credentials: "include", ...init });
+  } catch {
+    return null;
+  }
+  if (res.status === 401) throw new SessionExpired();
+  return res;
+}
+var postInit = (body) => ({
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body)
+});
+async function ensureLease(min = LEASE_MIN) {
+  if (!isOnline()) return;
+  const seqs = await getMeta("leaseSeqs") ?? [];
+  if (seqs.length >= min) return;
+  const res = await call("/sync/lease", postInit({ count: LEASE_BATCH }));
+  if (!res || !res.ok) return;
+  const { seqs: fresh } = await res.json();
+  await setMeta("leaseSeqs", [...seqs, ...fresh]);
+}
+async function pushOutbox() {
+  const pending = await db.outbox.toArray();
+  if (!pending.length) return;
+  const res = await call(
+    "/sync/push",
+    postInit({ tickets: pending.map((p) => p.payload) })
+  );
+  if (!res || !res.ok) return;
+  const { results } = await res.json();
+  await db.transaction("rw", db.outbox, db.tickets, async () => {
+    for (const r of results) {
+      if (r.ok) {
+        await db.outbox.delete(r.ovrTicketNo);
+        if (r.ticket) await db.tickets.put(r.ticket);
+      } else {
+        await db.outbox.update(r.ovrTicketNo, { status: "error", error: r.error });
+      }
+    }
+  });
+}
+async function pullAll() {
+  const [t, c, o, s] = await Promise.all([
+    call("/tickets"),
+    call("/violations"),
+    call("/officers"),
+    call("/tickets/stats")
+  ]);
+  if (!t || !c || !o || !s) return;
+  if (!t.ok || !c.ok || !o.ok || !s.ok) {
+    throw new Error(
+      `sync.pullAll failed: tickets=${t.status} catalog=${c.status} officers=${o.status} stats=${s.status}`
+    );
+  }
+  const tickets = await t.json();
+  const catalog = await c.json();
+  const officers = await o.json();
+  const stats = await s.json();
+  await db.transaction(
+    "rw",
+    db.tickets,
+    db.catalog,
+    db.officers,
+    db.meta,
+    async () => {
+      await db.tickets.bulkPut(tickets);
+      await db.catalog.clear();
+      await db.catalog.bulkPut(catalog);
+      await db.officers.clear();
+      await db.officers.bulkPut(officers);
+      await db.meta.put({ key: "stats", value: stats });
+    }
+  );
+  await setMeta("lastSyncedAt", (/* @__PURE__ */ new Date()).toISOString());
+}
+async function sync() {
+  if (!isOnline()) return;
+  await pushOutbox();
+  await ensureLease();
+  await pullAll();
+}
+
+// ../ovr-offline/src/issue.ts
+async function popSeq() {
+  return db.transaction("rw", db.meta, async () => {
+    const row = await db.meta.get("leaseSeqs");
+    const seqs = row?.value ?? [];
+    if (seqs.length === 0) return null;
+    await db.meta.put({ key: "leaseSeqs", value: seqs.slice(1) });
+    return seqs[0];
+  });
+}
+async function issueTicketOffline(input, rules) {
+  let seq = await popSeq();
+  if (seq === null && isOnline()) {
+    await ensureLease(50);
+    seq = await popSeq();
+  }
+  if (seq === null) {
+    throw new Error(
+      isOnline() ? "Couldn't reserve ticket numbers \u2014 please try again." : "No offline ticket numbers left. Reconnect to the internet to reserve more."
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ovrTicketNo = makeOvrTicketNo(rules.idPrefix, now.getFullYear(), seq);
+  const officer = await db.officers.get(input.officerId);
+  if (!officer) {
+    const cur = await getMeta("leaseSeqs") ?? [];
+    await setMeta("leaseSeqs", [seq, ...cur]);
+    throw new Error("That officer isn't available offline. Sync and try again.");
+  }
+  const catalog = await db.catalog.toArray();
+  const byCode = new Map(catalog.map((c) => [c.code, c]));
+  const violations = input.violations.map((x) => {
+    const c = byCode.get(x.catalogCode);
+    if (!c) throw new Error(`Unknown violation: ${x.catalogCode}`);
+    const v = {
+      catalogCode: c.code,
+      title: c.title,
+      basicFine: c.basicFine
+    };
+    if (x.details?.trim()) v.details = x.details.trim();
+    return v;
+  });
+  const basicFinesTotal = violations.reduce((s, v) => s + v.basicFine, 0);
+  const record = {
+    ovrTicketNo,
+    orderOfPaymentNo: makeOrderOfPaymentNo(ovrTicketNo),
+    billNo: makeBillNo(now, officer.office, officer.badgeNo ?? "X000", seq),
+    violator: input.violator,
+    apprehendedAt: input.apprehendedAt,
+    officer,
+    violations,
+    assessedAt: now.toISOString(),
+    dueDate: addDays(now, rules.dueWindowDays).toISOString(),
+    basicFinesTotal,
+    paymentStatus: "UNPAID",
+    createdAt: now.toISOString()
+  };
+  if (input.placeOfViolation?.trim())
+    record.placeOfViolation = input.placeOfViolation.trim();
+  if (input.remarks?.trim()) record.remarks = input.remarks.trim();
+  if (input.issuedBy?.trim()) record.issuedBy = input.issuedBy.trim();
+  if (input.apprehendingEnforcerId)
+    record.apprehendingEnforcerId = input.apprehendingEnforcerId;
+  if (input.apprehendingEnforcerName?.trim())
+    record.apprehendingEnforcerName = input.apprehendingEnforcerName.trim();
+  const ticket = enrich(record, now, rules.surchargeRatePerMonth);
+  await db.transaction("rw", db.tickets, db.outbox, async () => {
+    await db.tickets.put(ticket);
+    await db.outbox.put({
+      ovrTicketNo,
+      createdAt: record.createdAt,
+      status: "pending",
+      payload: {
+        ovrTicketNo,
+        createdAt: record.createdAt,
+        violator: input.violator,
+        apprehendedAt: input.apprehendedAt,
+        ...record.placeOfViolation ? { placeOfViolation: record.placeOfViolation } : {},
+        officerId: input.officerId,
+        violations: input.violations,
+        ...record.remarks ? { remarks: record.remarks } : {},
+        ...record.apprehendingEnforcerId ? { apprehendingEnforcerId: record.apprehendingEnforcerId } : {},
+        ...record.apprehendingEnforcerName ? { apprehendingEnforcerName: record.apprehendingEnforcerName } : {}
+      }
+    });
+  });
+  if (isOnline()) void pushOutbox().catch(() => {
+  });
+  return ticket;
+}
+async function getIdentity() {
+  return await getMeta("identity") ?? void 0;
+}
+async function clearIdentity() {
+  await setMeta("identity", null);
+}
+function useAdminAuth() {
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      const cached = await getMeta("identity");
+      if (isOnline()) {
+        try {
+          const res = await fetch(`${offlineApiBase()}/auth/me`, {
+            credentials: "include"
+          });
+          if (res.ok) {
+            const { user } = await res.json();
+            await setMeta("identity", user);
+            if (!cancelled) setState({ status: "authed", user });
+            return;
+          }
+          await setMeta("identity", null);
+          if (!cancelled) setState({ status: "unauthed" });
+          return;
+        } catch {
+        }
+      }
+      if (!cancelled) {
+        setState(
+          cached ? { status: "authed", user: cached } : { status: "unauthed" }
+        );
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return state;
+}
+var PBKDF2_ITERATIONS = 21e4;
+function subtle() {
+  return typeof crypto !== "undefined" && crypto.subtle ? crypto.subtle : null;
+}
+var toHex = (buf) => Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, "0")).join(
+  ""
+);
+function fromHex(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++)
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+async function deriveHashHex(password, salt, iterations) {
+  const s = subtle();
+  if (!s) return null;
+  const keyMaterial = await s.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const bits = await s.deriveBits(
+    { name: "PBKDF2", salt, iterations, hash: "SHA-256" },
+    keyMaterial,
+    256
+  );
+  return toHex(bits);
+}
+async function cacheCredential(username, password, identity) {
+  if (!subtle()) return;
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const hashHex = await deriveHashHex(password, salt, PBKDF2_ITERATIONS);
+  if (!hashHex) return;
+  const cred = {
+    username: username.trim(),
+    saltHex: toHex(salt.buffer),
+    hashHex,
+    iterations: PBKDF2_ITERATIONS,
+    identity
+  };
+  await setMeta("credential", cred);
+}
+async function verifyOffline(username, password) {
+  const cred = await getMeta("credential");
+  if (!cred || cred.username !== username.trim()) return null;
+  const hashHex = await deriveHashHex(
+    password,
+    fromHex(cred.saltHex),
+    cred.iterations
+  );
+  if (!hashHex || hashHex !== cred.hashHex) return null;
+  await setMeta("identity", cred.identity);
+  return cred.identity;
+}
+function useTickets() {
+  return useLiveQuery(() => db.tickets.orderBy("createdAt").reverse().toArray());
+}
+function useCatalog() {
+  return useLiveQuery(() => db.catalog.orderBy("category").toArray());
+}
+function useOfficers() {
+  return useLiveQuery(() => db.officers.toArray());
+}
+function useIdentity() {
+  return useLiveQuery(
+    async () => (await db.meta.get("identity"))?.value
+  );
+}
+function useNotifications() {
+  const tickets = useTickets();
+  if (!tickets) return [];
+  const items = [];
+  for (const t of tickets) {
+    const type = t.status === "OVERDUE" ? "overdue" : t.status === "OUTSTANDING" ? "outstanding" : null;
+    if (!type) continue;
+    items.push({
+      id: `${t.ovrTicketNo}:${type}`,
+      type,
+      ovrTicketNo: t.ovrTicketNo,
+      name: fullName(t.violator),
+      at: type === "overdue" ? t.dueDate : t.createdAt,
+      href: `/admin/tickets/${encodeURIComponent(t.ovrTicketNo)}`
+    });
+  }
+  const rank = (n) => n.type === "overdue" ? 0 : 1;
+  items.sort((a, b) => rank(a) - rank(b) || (a.at < b.at ? 1 : a.at > b.at ? -1 : 0));
+  return items;
+}
+function notifSignature(items) {
+  return items.map((n) => n.id).join("|");
+}
+function useNotificationsState() {
+  const items = useNotifications();
+  const seen = useLiveQuery(
+    async () => (await db.meta.get("notif_seen"))?.value
+  );
+  const signature = notifSignature(items);
+  return {
+    items,
+    total: items.length,
+    unseen: items.length > 0 && signature !== seen,
+    markSeen: () => {
+      void setMeta("notif_seen", signature);
+    }
+  };
+}
+function useStats() {
+  return useLiveQuery(
+    async () => (await db.meta.get("stats"))?.value
+  );
+}
+function useTicket(ovrTicketNo) {
+  return useLiveQuery(
+    async () => await db.tickets.get(ovrTicketNo) ?? null,
+    [ovrTicketNo]
+  );
+}
+function usePendingSync() {
+  const rows = useLiveQuery(() => db.outbox.toArray());
+  return new Set((rows ?? []).map((r) => r.ovrTicketNo));
+}
+function useSync() {
+  const [syncing, setSyncing] = useState(false);
+  const [online, setOnline] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    setOnline(isOnline());
+    async function runSyncCycle() {
+      if (!isOnline()) return;
+      setSyncing(true);
+      setError(null);
+      try {
+        await sync();
+      } catch (e) {
+        if (e instanceof SessionExpired) {
+          await clearIdentity();
+          window.location.assign("/admin/login");
+          return;
+        }
+        if (!cancelled) setError(e instanceof Error ? e.message : "sync failed");
+      } finally {
+        if (!cancelled) setSyncing(false);
+      }
+    }
+    const onOnline = () => {
+      setOnline(true);
+      void runSyncCycle();
+    };
+    const onOffline = () => setOnline(false);
+    void runSyncCycle();
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("online", onOnline);
+      window.removeEventListener("offline", onOffline);
+    };
+  }, []);
+  return { syncing, online, error };
+}
+
+export { SessionExpired, cacheCredential, clearIdentity, db, ensureLease, getIdentity, getMeta, isOnline, issueTicketOffline, offlineApiBase, pullAll, pushOutbox, setMeta, setOfflineApiBase, sync, useAdminAuth, useCatalog, useIdentity, useNotifications, useNotificationsState, useOfficers, usePendingSync, useStats, useSync, useTicket, useTickets, verifyOffline };

package/dist/{chunk-GDOCD7LT.js → chunk-ZUMEOZ22.js}

@@ -1,9 +1,9 @@
-import { ViolationsTable } from './chunk-JEYT63LE.js';
-import { AmountSummary } from './chunk-BIQ2J75Y.js';
-import { Card, CardHeader, CardTitle, CardContent } from './chunk-SETIN6XP.js';
+import { ViolationsTable } from './chunk-IBZVIUNI.js';
+import { AmountSummary } from './chunk-GLIK5BHP.js';
 import { StatusBadge } from './chunk-OE525ZER.js';
-import { useFormatters } from './chunk-E2D7QT6N.js';
-import { formalName, formatAddress } from './chunk-B634JHKZ.js';
+import { Card, CardHeader, CardTitle, CardContent } from './chunk-SETIN6XP.js';
+import { useFormatters } from './chunk-TJSNVTVB.js';
+import { formalName, formatAddress } from './chunk-BI4EGLPG.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 
 function Field({ label, value }) {

package/dist/core-i18n.d.ts

@@ -1,5 +1,5 @@
-import { C as CopyOverrides, D as Dictionary } from './types-CtBC5-TW.js';
-export { b as baseCopy } from './types-CtBC5-TW.js';
+import { C as CopyOverrides, D as Dictionary } from './types-BOgdk0Jw.js';
+export { b as baseCopy } from './types-BOgdk0Jw.js';
 import { M as MunicipalityConfig } from './schema-CdsFQxIg.js';
 import 'zod';
 

package/dist/core-i18n.js

@@ -1 +1 @@
-export { baseCopy, mergeCopy } from './chunk-5YYR37CF.js';
+export { baseCopy, mergeCopy } from './chunk-HGWPA7FU.js';

package/dist/core.d.ts

@@ -73,4 +73,64 @@ interface IssuanceDraft {
 type PreviewRules = Pick<RulesConfig, "dueWindowDays" | "surchargeRatePerMonth">;
 declare function toPreviewTicket(draft: IssuanceDraft, now: Date, rules: PreviewRules): Ticket;
 
-export { type ChargeInput, type ChargeResult, type IssuanceDraft, PREVIEW_PLACEHOLDER, type PreviewRules, computeCharges, enrich, makeBillNo, makeOrderOfPaymentNo, makeOvrTicketNo, makePaymentRef, round2, startedMonthsSince, toPreviewTicket };
+/**
+ * Dashboard time-range presets (GE-010): 1D / 7D / MTD / prev-MTD (+ All).
+ *
+ * Ranges are computed in the LGU's timezone (config `timeZone`) so "today" / "this
+ * month" mean the local calendar, not the server's. Stats are derived from the
+ * on-device ticket list (offline-first) — no server round-trip — by ISSUE date
+ * (`createdAt`); each card reflects the CURRENT status of tickets issued in range.
+ */
+
+type DashboardRangePreset = "1d" | "7d" | "mtd" | "prev-mtd" | "all";
+interface DashboardPreset {
+    key: DashboardRangePreset;
+    label: string;
+}
+/** The presets, in display order. */
+declare const DASHBOARD_PRESETS: DashboardPreset[];
+interface DashboardRange {
+    /** Inclusive lower bound (ISO), or null for "all time" (no lower bound). */
+    fromISO: string | null;
+    /** Inclusive upper bound (ISO). */
+    toISO: string;
+}
+interface DashboardStats {
+    issued: number;
+    outstanding: number;
+    overdue: number;
+    paid: number;
+    collected: number;
+}
+/** Resolve a preset to a concrete [from, to] range, anchored to `now` in `timeZone`. */
+declare function dashboardDateRange(preset: DashboardRangePreset, now: Date, timeZone: string): DashboardRange;
+/** A custom date range from two `YYYY-MM-DD` local dates (either may be empty:
+ *  empty `from` → no lower bound; empty `to` → up to `now`). Interpreted in
+ *  `timeZone` as [from 00:00:00, to 23:59:59]. If from > to, they're swapped. */
+declare function customDateRange(fromYMD: string | null | undefined, toYMD: string | null | undefined, now: Date, timeZone: string): DashboardRange;
+/** Compute the dashboard cards from the local ticket list, scoped to `range`
+ *  by issue date. Each card reflects each ticket's CURRENT status. */
+declare function computeDashboardStats(tickets: Ticket[], range: DashboardRange): DashboardStats;
+
+/**
+ * Philippine locations (PSGC) for the Issue-Ticket address dropdowns (GE-015).
+ *
+ * Provinces + their cities/municipalities ONLY (barangays omitted to keep the
+ * bundle small — barangay stays free-text). Bundled (no runtime API) so it works
+ * offline. NCR districts are flattened into a single "Metro Manila" province.
+ *
+ * Source (open data, CC0/public): flores-jacob/philippine-regions-provinces-
+ * cities-municipalities-barangays (2019v2, derived from PSA PSGC). Names are
+ * title-cased from the source's all-caps.
+ */
+interface PhProvince {
+    province: string;
+    cities: string[];
+}
+declare const PH_PROVINCES: PhProvince[];
+/** All province names (display order = alphabetical). */
+declare function listProvinces(): string[];
+/** Cities/municipalities of a province (case-insensitive match; [] if unknown). */
+declare function citiesOfProvince(province: string | null | undefined): string[];
+
+export { type ChargeInput, type ChargeResult, DASHBOARD_PRESETS, type DashboardPreset, type DashboardRange, type DashboardRangePreset, type DashboardStats, type IssuanceDraft, PH_PROVINCES, PREVIEW_PLACEHOLDER, type PhProvince, type PreviewRules, citiesOfProvince, computeCharges, computeDashboardStats, customDateRange, dashboardDateRange, enrich, listProvinces, makeBillNo, makeOrderOfPaymentNo, makeOvrTicketNo, makePaymentRef, round2, startedMonthsSince, toPreviewTicket };

package/dist/core.js

@@ -1 +1 @@
-export { PREVIEW_PLACEHOLDER, addDays, computeCharges, createFormatters, enrich, formalName, formatAddress, fullName, localToManilaISO, makeBillNo, makeOrderOfPaymentNo, makeOvrTicketNo, makePaymentRef, round2, startedMonthsSince, toPreviewTicket } from './chunk-B634JHKZ.js';
+export { DASHBOARD_PRESETS, PH_PROVINCES, PREVIEW_PLACEHOLDER, addDays, citiesOfProvince, computeCharges, computeDashboardStats, createFormatters, customDateRange, dashboardDateRange, enrich, formalName, formatAddress, fullName, listProvinces, localToManilaISO, makeBillNo, makeOrderOfPaymentNo, makeOvrTicketNo, makePaymentRef, round2, startedMonthsSince, toPreviewTicket } from './chunk-BI4EGLPG.js';