@goplusvn/core 0.1.4 → 0.1.6

package/src/print/direct-print-provider.tsx

@@ -0,0 +1,333 @@
+"use client"
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react"
+
+import { Loader2 } from "lucide-react"
+
+import { PrintStyles } from "./print-styles"
+
+/**
+ * Generic, document-agnostic print device layer.
+ *
+ * Two print modes funnel through `triggerDirectPrint`:
+ *  1. URL mode `{ printUrl }` — renders the URL in a hidden iframe and prints it
+ *     (with a same-tab `?autoPrint=1` fallback on mobile, where iframe printing
+ *     is unreliable). This is the canonical path and is fully generic.
+ *  2. Payload mode `{ type, data }` — renders the document INLINE via the
+ *     app-supplied `renderContent` render-prop. Core owns the print mechanics;
+ *     the app owns what the document looks like. If `renderContent` is omitted,
+ *     payload mode is a no-op (URL mode still works).
+ *
+ * Mount once near the app root and trigger from anywhere via `useDirectPrint`.
+ */
+
+export interface DirectPrintPayload {
+  type: string
+  data: unknown
+}
+
+export interface DirectPrintUrlPayload {
+  printUrl: string
+}
+
+interface DirectPrintContextValue {
+  triggerDirectPrint: (
+    payload: DirectPrintPayload | DirectPrintUrlPayload | null
+  ) => void
+}
+
+const DirectPrintContext = createContext<DirectPrintContextValue | null>(null)
+
+export function useDirectPrint(): DirectPrintContextValue {
+  const ctx = useContext(DirectPrintContext)
+  if (!ctx) {
+    return {
+      triggerDirectPrint: () => {
+        // No-op when used outside provider
+      },
+    }
+  }
+  return ctx
+}
+
+/** ~297mm A4 at 96dpi. Only used for payload printing (not iframe printing). */
+const ONE_PAGE_HEIGHT_PX = 1300
+const ONE_PAGE_LIMIT_STYLE_ID = "direct-print-one-page-limit"
+
+function isMobilePrintEnvironment(): boolean {
+  if (typeof navigator === "undefined") return false
+  const ua = navigator.userAgent || ""
+  // iPadOS may report as Macintosh with touch points
+  const isIpadOs = /Macintosh/.test(ua) && navigator.maxTouchPoints > 1
+  return /Android|iPhone|iPad|iPod/i.test(ua) || isIpadOs
+}
+
+function appendQueryParam(url: string, key: string, value: string): string {
+  const hasQuery = url.includes("?")
+  const hasHash = url.includes("#")
+  if (hasHash) {
+    const [base, hash] = url.split("#")
+    const sep = hasQuery ? "&" : "?"
+    return `${base}${sep}${encodeURIComponent(key)}=${encodeURIComponent(value)}#${hash}`
+  }
+  const sep = hasQuery ? "&" : "?"
+  return `${url}${sep}${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+}
+
+function isPrintUrlPayload(
+  v: DirectPrintPayload | DirectPrintUrlPayload
+): v is DirectPrintUrlPayload {
+  return (
+    "printUrl" in v && typeof (v as DirectPrintUrlPayload).printUrl === "string"
+  )
+}
+
+export interface DirectPrintProviderProps {
+  children: ReactNode
+  /**
+   * Render the document for payload-mode prints (`{ type, data }`). Omit if the
+   * app only ever prints via URL mode.
+   */
+  renderContent?: (payload: DirectPrintPayload) => ReactNode
+  /** Loading overlay text (defaults to Vietnamese). */
+  loadingText?: string
+  loadingSubText?: string
+}
+
+export function DirectPrintProvider({
+  children,
+  renderContent,
+  loadingText = "Đang chuẩn bị trang in...",
+  loadingSubText = "Vui lòng đợi trong giây lát",
+}: DirectPrintProviderProps) {
+  const [payload, setPayload] = useState<DirectPrintPayload | null>(null)
+  const [printUrlPending, setPrintUrlPending] = useState<string | null>(null)
+  const afterprintRef = useRef<(() => void) | null>(null)
+  const fallbackRef = useRef<number | null>(null)
+  const iframeRef = useRef<HTMLIFrameElement | null>(null)
+
+  const triggerDirectPrint = useCallback(
+    (value: DirectPrintPayload | DirectPrintUrlPayload | null) => {
+      if (!value) {
+        setPayload(null)
+        setPrintUrlPending(null)
+        return
+      }
+      if (isPrintUrlPayload(value)) {
+        setPayload(null)
+        setPrintUrlPending(value.printUrl)
+        return
+      }
+      setPrintUrlPending(null)
+      setPayload(value)
+    },
+    []
+  )
+
+  useEffect(() => {
+    if (!printUrlPending) return
+
+    // Mobile browsers (esp. iOS Safari) often can't print hidden iframes reliably.
+    // Fallback: navigate to the print URL in the same tab and let that page auto-print.
+    if (isMobilePrintEnvironment()) {
+      const urlWithAutoPrint = appendQueryParam(
+        printUrlPending,
+        "autoPrint",
+        "1"
+      )
+      window.location.assign(urlWithAutoPrint)
+      return
+    }
+
+    const url =
+      printUrlPending.startsWith("http") || printUrlPending.startsWith("//")
+        ? printUrlPending
+        : `${typeof window !== "undefined" ? window.location.origin : ""}${printUrlPending}`
+
+    const iframe = document.createElement("iframe")
+    iframe.setAttribute(
+      "style",
+      "position:fixed;left:-9999px;top:0;width:210mm;height:297mm;border:none;visibility:hidden;"
+    )
+    document.body.appendChild(iframe)
+    iframeRef.current = iframe
+
+    let fallbackTimer: ReturnType<typeof setTimeout> | null = null
+    let isCleanedUp = false
+
+    const cleanup = () => {
+      if (isCleanedUp) return
+      isCleanedUp = true
+      if (iframe.parentNode) {
+        iframe.parentNode.removeChild(iframe)
+      }
+      if (iframeRef.current === iframe) {
+        iframeRef.current = null
+      }
+      setPrintUrlPending(null)
+    }
+
+    const onLoad = () => {
+      const win = iframe.contentWindow
+      if (!win) {
+        cleanup()
+        return
+      }
+
+      const onAfterPrint = () => {
+        win.removeEventListener("afterprint", onAfterPrint)
+        cleanup()
+      }
+      win.addEventListener("afterprint", onAfterPrint)
+
+      // Delay longer to let Chrome fully render DOM inside iframe
+      setTimeout(() => {
+        try {
+          win.focus()
+          win.print()
+        } catch (err) {
+          console.error("Popup Error:", err)
+        }
+
+        // Firefox/Safari fallback (if afterprint doesn't fire)
+        fallbackTimer = setTimeout(cleanup, 3000)
+      }, 500)
+    }
+
+    iframe.addEventListener("load", onLoad, { once: true })
+    iframe.src = url
+
+    return () => {
+      iframe.removeEventListener("load", onLoad)
+      if (fallbackTimer) clearTimeout(fallbackTimer)
+      if (iframe.parentNode) iframe.parentNode.removeChild(iframe)
+      if (iframeRef.current === iframe) {
+        iframeRef.current = null
+      }
+    }
+  }, [printUrlPending])
+
+  useEffect(() => {
+    if (!payload) return
+
+    const clearPayload = () => {
+      setPayload(null)
+      afterprintRef.current = null
+      document.getElementById(ONE_PAGE_LIMIT_STYLE_ID)?.remove()
+    }
+
+    afterprintRef.current = clearPayload
+
+    const handleAfterPrint = () => {
+      if (fallbackRef.current) {
+        clearTimeout(fallbackRef.current)
+        fallbackRef.current = null
+      }
+      document.getElementById(ONE_PAGE_LIMIT_STYLE_ID)?.remove()
+      afterprintRef.current?.()
+      window.removeEventListener("afterprint", handleAfterPrint)
+    }
+
+    window.addEventListener("afterprint", handleAfterPrint)
+
+    const timer = setTimeout(() => {
+      const root = document.getElementById("direct-print-root")
+      const printContent = document.getElementById("print-content")
+      root?.offsetHeight
+      printContent?.offsetHeight
+      const contentHeight =
+        printContent?.scrollHeight ?? root?.scrollHeight ?? 0
+      const isSinglePage =
+        contentHeight > 0 && contentHeight <= ONE_PAGE_HEIGHT_PX
+      if (isSinglePage) {
+        const style = document.createElement("style")
+        style.id = ONE_PAGE_LIMIT_STYLE_ID
+        style.textContent = `@media print { html, body { height: 297mm !important; max-height: 297mm !important; overflow: hidden !important; } }`
+        document.head.appendChild(style)
+      }
+      window.print()
+      fallbackRef.current = window.setTimeout(clearPayload, 1000)
+    }, 150)
+
+    return () => {
+      clearTimeout(timer)
+      if (fallbackRef.current) clearTimeout(fallbackRef.current)
+      window.removeEventListener("afterprint", handleAfterPrint)
+      document.getElementById(ONE_PAGE_LIMIT_STYLE_ID)?.remove()
+    }
+  }, [payload])
+
+  return (
+    <DirectPrintContext.Provider value={{ triggerDirectPrint }}>
+      {children}
+
+      {/* Screen: hide off-screen. Print: show only #direct-print-root. */}
+      <style
+        dangerouslySetInnerHTML={{
+          __html: [
+            "@media screen { #direct-print-root { position: fixed !important; left: -9999px !important; top: 0 !important; width: 210mm !important; max-width: 100% !important; z-index: -1 !important; visibility: hidden !important; pointer-events: none !important; } }",
+            "@media print { #direct-print-root { visibility: visible !important; position: absolute !important; left: 0 !important; top: 0 !important; width: 100% !important; z-index: 9999 !important; pointer-events: auto !important; } }",
+          ].join(" "),
+        }}
+      />
+
+      <div
+        id="direct-print-root"
+        aria-hidden="true"
+        className="print-container"
+      >
+        {payload && renderContent && (
+          <>
+            <PrintStyles />
+            <div id="print-content">{renderContent(payload)}</div>
+          </>
+        )}
+      </div>
+
+      {/* Loading Overlay */}
+      {(printUrlPending || payload) && (
+        <div
+          className="print-loading-overlay"
+          style={{
+            position: "fixed",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            backgroundColor: "rgba(255, 255, 255, 0.7)",
+            zIndex: 99999,
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            color: "#1e293b",
+          }}
+        >
+          <div className="bg-white p-6 rounded-2xl shadow-xl flex flex-col items-center gap-4">
+            <Loader2 className="w-10 h-10 animate-spin text-blue-600" />
+            <div className="text-sm font-semibold text-slate-700">
+              {loadingText}
+            </div>
+            <div className="text-xs text-slate-500">{loadingSubText}</div>
+          </div>
+        </div>
+      )}
+
+      {/* Hide Overlay while printing from same window */}
+      <style
+        dangerouslySetInnerHTML={{
+          __html:
+            "@media print { .print-loading-overlay { display: none !important; visibility: hidden !important; } }",
+        }}
+      />
+    </DirectPrintContext.Provider>
+  )
+}

package/src/print/index.ts

@@ -0,0 +1,11 @@
+export {
+  DirectPrintProvider,
+  useDirectPrint,
+} from "./direct-print-provider"
+export type {
+  DirectPrintPayload,
+  DirectPrintUrlPayload,
+  DirectPrintProviderProps,
+} from "./direct-print-provider"
+export { PrintStyles } from "./print-styles"
+export type { PrintStylesProps } from "./print-styles"

package/src/print/print-styles.tsx

@@ -0,0 +1,234 @@
+"use client"
+
+export interface PrintStylesProps {
+  pageSize?: "A4" | "A5-Portrait" | "A5-Landscape"
+}
+
+export function PrintStyles({ pageSize = "A4" }: PrintStylesProps) {
+  // A5 Portrait: 148.5mm x 210mm
+  // A5 Landscape: 210mm x 148.5mm
+  // A4: 210mm x 297mm
+
+  const getPageConfig = () => {
+    switch (pageSize) {
+      case "A5-Portrait":
+        return {
+          size: "A5",
+          maxWidth: "148.5mm", // width
+          padding: "10mm 8mm", // increased top padding from 5mm
+          fontSize: "9.5pt",
+        }
+      case "A5-Landscape":
+        return {
+          size: "A5 landscape",
+          maxWidth: "210mm", // width
+          padding: "12mm 12mm", // increased top padding from 8mm
+          fontSize: "10pt",
+        }
+      case "A4":
+      default:
+        return {
+          size: "A4",
+          maxWidth: "210mm",
+          padding: "12mm 12mm", // increased top padding from 8mm
+          fontSize: "10pt",
+        }
+    }
+  }
+
+  const config = getPageConfig()
+
+  return (
+    <style dangerouslySetInnerHTML={{ __html: `
+      @media print {
+        body {
+          visibility: hidden;
+        }
+        .no-print {
+          display: none !important;
+        }
+        .print-container,
+        #print-content {
+          visibility: visible;
+          position: absolute;
+          left: 0;
+          top: 2mm; /* Added a small offset from the literal top of the page */
+          width: 100%;
+          padding: ${config.padding};
+          font-size: ${config.fontSize};
+          line-height: 1.25;
+        }
+        @page {
+          size: ${config.size};
+          margin: 0;
+        }
+      }
+
+      .print-container,
+      #print-content {
+        max-width: ${config.maxWidth};
+        margin: 0 auto;
+        padding: 20px;
+        font-family: "Times New Roman", serif;
+        background: white;
+      }
+
+      /* Base layout */
+      ${pageSize === "A5-Portrait" ? `
+      .header-top h3 { font-size: 9pt; }
+      .header-top p { font-size: 8pt; }
+      table th, table td { font-size: 8.5pt; padding: 2px 3px; }
+      .info-label { min-width: 100px; }
+      .voucher-title { font-size: 14pt; margin: 5px 0; }
+      ` : `
+      .header-top h3 { font-size: 10pt; }
+      .header-top p { font-size: 9pt; }
+      table th, table td { font-size: 10pt; padding: 3px 5px; }
+      .info-label { min-width: 120px; }
+      `}
+
+      /* Header & Title */
+      .header {
+        text-align: center;
+        margin-bottom: 10px;
+      }
+      .header-top {
+        text-align: center;
+        margin-bottom: 5px;
+      }
+      .header-top h3 {
+        margin: 0;
+        text-transform: uppercase;
+        font-weight: bold;
+      }
+      .header-top p {
+        margin: 2px 0 0 0;
+        font-weight: bold;
+      }
+
+      /* Contract specific */
+      .contract-title {
+        text-align: center;
+        font-weight: bold;
+        font-size: 13pt;
+        margin: 10px 0;
+      }
+      .contract-number {
+        text-align: center;
+        margin-bottom: 10px;
+        font-style: italic;
+      }
+
+      /* Content sections */
+      .section-content {
+        margin-bottom: 8px;
+      }
+      .info-row {
+        margin-bottom: 3px;
+      }
+      .info-label {
+        font-weight: bold;
+        display: inline-block;
+      }
+
+      /* Tables */
+      table {
+        width: 100%;
+        border-collapse: collapse;
+        margin: 5px 0;
+      }
+      table th,
+      table td {
+        border: 1px solid #000;
+      }
+      table th {
+        text-align: center;
+        font-weight: bold;
+      }
+
+      /* Text utilities */
+      .text-right {
+        text-align: right;
+      }
+      .text-center {
+        text-align: center;
+      }
+      .text-bold {
+        font-weight: bold;
+      }
+      .amount-in-words {
+        margin: 5px 0;
+        font-style: italic;
+        font-weight: bold;
+      }
+      .d-flex-between {
+        display: flex;
+        justify-content: space-between;
+      }
+
+      /* Signature section */
+      .signature-section {
+        margin-top: 20px;
+        display: flex;
+        justify-content: space-between;
+      }
+      .signature-box {
+        width: 45%;
+        text-align: center;
+      }
+      .signature-box h4 {
+        margin: 0 0 40px 0;
+      }
+
+      /* Company header */
+      .company-header {
+        font-size: 9pt;
+        font-weight: normal;
+      }
+      .company-header .company-name {
+        text-transform: uppercase;
+      }
+
+      /* Template header right (mẫu số) */
+      .template-code {
+        font-weight: bold;
+        font-size: 11pt;
+      }
+      .template-note {
+        font-style: italic;
+        font-size: 10pt;
+      }
+
+      /* Voucher title */
+      .voucher-title {
+        margin: 10px 0;
+        font-weight: bold;
+        text-align: center;
+      }
+
+      /* Payment method row */
+      .payment-method-row {
+        display: flex;
+        justify-content: center;
+        gap: 30px;
+        font-weight: bold;
+        font-size: 11pt;
+        margin-bottom: 10px;
+      }
+      .payment-method-item {
+        display: flex;
+        align-items: center;
+        gap: 5px;
+      }
+      .payment-checkbox {
+        width: 16px;
+        height: 16px;
+        border: 1px solid #000;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 14px;
+      }
+    `}} />
+  )
+}

package/src/repository/cas-update.ts

@@ -0,0 +1,54 @@
+/**
+ * Compare-and-swap (CAS) update — the platform invariant for money/stock
+ * mutations across GoERP apps.
+ *
+ * Instead of read-modify-write (which double-applies under a lost race), a CAS
+ * update writes ONLY when the row still matches its expected current state, via
+ * `updateMany({ where: { ...expected }, data })`. When nothing matched (a
+ * concurrent writer already moved the state, or it was stale), it throws the
+ * caller-supplied `conflictError` so an enclosing `$transaction` rolls back
+ * rather than silently corrupting a balance / stock count.
+ *
+ * Prisma-agnostic on purpose: pass any model delegate (or transaction-bound
+ * delegate) — only `updateMany` is required.
+ */
+
+/** The slice of a Prisma model delegate that CAS needs. */
+export interface CasDelegate {
+  updateMany(args: {
+    where: Record<string, unknown>
+    data: Record<string, unknown>
+  }): Promise<{ count: number }>
+}
+
+/**
+ * Run a CAS update against an already-built `where` (which must encode the
+ * expected current state). Throws `conflictError` if no row matched.
+ */
+export async function casUpdate<R extends { count: number }>(
+  delegate: { updateMany(args: { where: any; data: any }): Promise<R> },
+  where: Record<string, unknown>,
+  data: Record<string, unknown>,
+  conflictError: Error
+): Promise<R> {
+  const result = await delegate.updateMany({ where, data })
+  if (result.count === 0) {
+    throw conflictError
+  }
+  return result
+}
+
+/**
+ * The common case: CAS a single row by `id` plus an `expectedWhere` describing
+ * its expected current state (e.g. `{ paymentStatus: { not: "paid" } }`). Builds
+ * `where: { id, ...expectedWhere }` and delegates to {@link casUpdate}.
+ */
+export function casUpdateById<R extends { count: number }>(
+  delegate: { updateMany(args: { where: any; data: any }): Promise<R> },
+  id: string,
+  expectedWhere: Record<string, unknown>,
+  data: Record<string, unknown>,
+  conflictError: Error
+): Promise<R> {
+  return casUpdate(delegate, { id, ...expectedWhere }, data, conflictError)
+}

package/src/repository/index.ts

@@ -0,0 +1,2 @@
+export { casUpdate, casUpdateById } from "./cas-update"
+export type { CasDelegate } from "./cas-update"