@7365admin1/layer-common 4.84.0 → 4.84.1-staging.482

package/utils/occupancy-role.ts

@@ -0,0 +1,109 @@
+/**
+ * OWNER / OCCUPANT / PERSON IN CHARGE - the three standings a business
+ * tenancy has, and everything the product says about them.
+ *
+ * One list, because three screens read it: the form that asks the question
+ * (`PeopleFormMgmt`), the list and preview that print the answer back, and
+ * the row menu that reassigns it (`people-mgmt`). The values are the ones the
+ * server stores and validates - `OccupancyRoles` in core's `person.model.ts`
+ * - so a value added on one side has to be added on the other.
+ */
+export const OCCUPANCY_ROLE_OPTIONS: TOccupancyRoleOption[] = [
+  {
+    value: "owner",
+    title: "Owner",
+    action: "Assign Owner",
+    prompt: "Assign Owner",
+    description:
+      "The legal titleholder or primary deed owner of the property.",
+  },
+  {
+    value: "occupant",
+    title: "Occupant",
+    action: "Assign Occupant",
+    prompt: "Assign Occupant",
+    description:
+      "The person currently living in, renting, or utilizing the physical unit.",
+  },
+  {
+    value: "person-in-charge",
+    title: "Person in Charge",
+    action: "Assign Person in Charge",
+    prompt: "Assign Person in Charge (PIC)",
+    description:
+      "The designated manager responsible for maintenance, emergencies, and daily operations.",
+  },
+];
+
+/**
+ * The same three, in the order the ROW MENU draws them, which is not the
+ * order the form's radio does. Derived rather than re-typed so the wording
+ * cannot drift between the two.
+ */
+export const OCCUPANCY_ROLE_ACTIONS: TOccupancyRoleOption[] = (
+  ["person-in-charge", "owner", "occupant"] as TOccupancyRole[]
+).map(
+  (value) =>
+    OCCUPANCY_ROLE_OPTIONS.find(
+      (option) => option.value === value,
+    ) as TOccupancyRoleOption,
+);
+
+/**
+ * The label for a stored role, or "" for a person who was never asked - which
+ * is everyone on a residential site and everyone saved before the question
+ * existed. Callers decide what to print instead; nobody should print a raw
+ * `person-in-charge` at a user.
+ */
+export function occupancyRoleLabel(role?: string | null): string {
+  return (
+    OCCUPANCY_ROLE_OPTIONS.find((option) => option.value === role)?.title ?? ""
+  );
+}
+
+/**
+ * Does this person hold OWNER at their unit?
+ *
+ * The role when there is one, `isOwner` when there is not - the same test the
+ * server applies (`holdsUnitOwner` in core's `unit-owner.util.ts`). A person
+ * recorded before the role existed carries only the flag, and the people list
+ * already prints them as "Owner".
+ */
+export function holdsUnitOwner(person?: {
+  occupancyRole?: string | null;
+  isOwner?: boolean;
+}): boolean {
+  if (!person) return false;
+
+  if (person.occupancyRole) return person.occupancyRole === "owner";
+
+  return person.isOwner === true;
+}
+
+/**
+ * MUST THIS PERSON HAND THE UNIT OVER BEFORE THEY CAN BE DEACTIVATED?
+ *
+ * The owner of a unit does not leave while they still own it - the standing
+ * moves to another tenant at the same block, level and unit first.
+ *
+ * Keyed to the ROLE and never to `isOwner`, exactly as the server keys it
+ * (`mustHandOverBeforeDeactivating` in core): the flag is on every resident in
+ * the estate, and no residential screen can change it, so a rule keyed to it
+ * would trap records that can never satisfy it.
+ */
+export function mustHandOverBeforeDeactivating(person?: {
+  occupancyRole?: string | null;
+}): boolean {
+  return person?.occupancyRole === "owner";
+}
+
+/**
+ * Why a deactivation was held back. The SERVER carries the enforcing copy of
+ * this rule and of these words (core `unit-owner.util.ts`); this one exists so
+ * the console can say it before the round trip rather than after.
+ */
+export function ownerHandoverRequiredMessage(name?: string): string {
+  const who = name?.trim() ? `"${name.trim()}"` : "This person";
+
+  return `${who} is the owner of this unit. Assign the owner role to another tenant at the same block, level and unit before deactivating them.`;
+}

package/utils/sanitize-html.ts

@@ -0,0 +1,16 @@
+import DOMPurify from "dompurify";
+
+/**
+ * The one way rich text typed by a user (announcements, facility descriptions,
+ * policies) reaches `v-html`. Keeps formatting, drops scripts, event handlers,
+ * `javascript:` links and embedded frames/forms. Browser-only (the apps are
+ * `ssr: false`); without a DOM it returns "" rather than unsanitised HTML.
+ */
+export function sanitizeHtml(html: unknown): string {
+  if (html === null || html === undefined || html === "") return "";
+  if (typeof window === "undefined" || !DOMPurify.isSupported) return "";
+  return DOMPurify.sanitize(String(html), {
+    USE_PROFILES: { html: true },
+    FORBID_TAGS: ["style", "form", "input", "button", "iframe", "object", "embed"],
+  });
+}

package/utils/security-headers.ts

@@ -0,0 +1,52 @@
+/**
+ * Response headers every web app sends, on the HTML shell (Nitro route rules)
+ * and on the static files (nitro writes the same rules into Cloudflare's
+ * `_headers`). One list, so the eleven apps cannot drift apart.
+ *
+ * The ENFORCED Content-Security-Policy only carries the directives that cannot
+ * break a screen: who may frame us (clickjacking), no plugins, no <base> swap.
+ * The full policy ships as Report-Only first: the apps load Google Fonts,
+ * camera players and documents in iframes, sockets and the Spaces CDN, and a
+ * wrong guess there blanks a page. Violations show in the browser console;
+ * once a release runs clean, move it to the enforced header.
+ *
+ * HSTS deliberately has no `preload`: preload is decided for the whole
+ * iservice365.org domain at the apex and is hard to undo (owner/leads action).
+ */
+export const CSP_ENFORCED = [
+  "frame-ancestors 'self'",
+  "object-src 'none'",
+  "base-uri 'self'",
+].join("; ");
+
+export const CSP_REPORT_ONLY = [
+  "default-src 'self'",
+  "script-src 'self'",
+  "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",
+  "font-src 'self' data: https://fonts.gstatic.com",
+  "img-src 'self' data: blob: https:",
+  "media-src 'self' blob: https:",
+  "connect-src 'self' https: wss:",
+  "frame-src 'self' https:",
+  "worker-src 'self' blob:",
+  "object-src 'none'",
+  "base-uri 'self'",
+  "frame-ancestors 'self'",
+  "form-action 'self' https:",
+  "upgrade-insecure-requests",
+].join("; ");
+
+export const SECURITY_HEADERS: Record<string, string> = {
+  "strict-transport-security": "max-age=31536000; includeSubDomains",
+  "x-content-type-options": "nosniff",
+  "x-frame-options": "SAMEORIGIN",
+  "referrer-policy": "strict-origin-when-cross-origin",
+  // camera/mic: QR scan, photo capture; geolocation: attendance;
+  // usb/serial/hid: card readers (useWebUsb). Everything else is off.
+  "permissions-policy":
+    "camera=(self), microphone=(self), geolocation=(self), usb=(self), serial=(self), hid=(self), payment=(self), display-capture=(self), bluetooth=(), midi=(), magnetometer=(), gyroscope=(), accelerometer=()",
+  // allow-popups: payment and document windows we open keep working.
+  "cross-origin-opener-policy": "same-origin-allow-popups",
+  "content-security-policy": CSP_ENFORCED,
+  "content-security-policy-report-only": CSP_REPORT_ONLY,
+};

package/utils/service-type.ts

@@ -0,0 +1,30 @@
+/**
+ * A SERVICE PROVIDER'S LINE OF BUSINESS, AS PEOPLE NAME IT.
+ *
+ * `/api/service-providers` returns the service CODE (`mechanical_electrical_services`),
+ * which is a database value, not something to show an operator. This is the same
+ * mapping `API-core src/utils/converter.ts spmServiceNewToOld` applies — copied
+ * rather than imported, because that is a server package this layer does not
+ * depend on.
+ *
+ * NOT the same labels as `utils/module-applications.ts APPLICATIONS`. Those name
+ * the seven role-permission applications ("Mechanical & electrical", "Pest
+ * control") and are keyed `mechanical-electrical`, not `*_services`. These are
+ * the shorter names the service-provider screens use ("M&E", "Pest Control").
+ *
+ * An unknown code is returned untouched: a new service type shows as its raw
+ * code, which is visibly odd, rather than vanishing from the row.
+ */
+const SERVICE_TYPE_LABELS: Readonly<Record<string, string>> = Object.freeze({
+  security_agency: "Security",
+  cleaning_services: "Cleaning",
+  pool_maintenance_services: "Pool Maintenance",
+  pest_control_services: "Pest Control",
+  landscaping_services: "Landscape",
+  mechanical_electrical_services: "Mechanical & Electrical",
+});
+
+export function serviceTypeLabel(service: string | null | undefined): string {
+  const code = String(service ?? "");
+  return SERVICE_TYPE_LABELS[code] ?? code;
+}

package/utils/site-actions.ts

@@ -0,0 +1,18 @@
+/**
+ * What the signed-in person may do with an organisation's sites, as core
+ * answers it (`GET /api/customer-sites?withActions=true` -> `siteActions`).
+ *
+ * Owner rule 2026-10-01: creating, deleting or removing sites is for Seven365
+ * Super Admin, the organisation's owner and organisation-level members with the
+ * right; a member confined to sites never - whatever their role says. The
+ * server decides and refuses (403); the UI only hides what would be refused.
+ * Anything missing or unreadable reads as "no" (the button stays hidden).
+ */
+export type TSiteActions = { create: boolean; delete: boolean; createCustomer: boolean };
+
+export const NO_SITE_ACTIONS: TSiteActions = Object.freeze({ create: false, delete: false, createCustomer: false });
+
+export function siteActionsOf(response: unknown): TSiteActions {
+  const a = (response as { siteActions?: Record<string, unknown> } | null)?.siteActions ?? {};
+  return { create: a.create === true, delete: a.delete === true, createCustomer: a.createCustomer === true };
+}

package/utils/site-provider-members.ts

@@ -43,6 +43,43 @@ export function companyChipText(name: string, people: number): string {
   return `${name || "Unnamed company"} · ${people} ${people === 1 ? "person" : "people"}`;
 }
 
+/**
+ * The Company filter (owner 2026-10-02: a proper filter instead of a row of
+ * company chips): one entry per company, narrowed to the chosen service,
+ * named with its service, head count and who brought it in.
+ */
+export function companyFilterItems(
+  companies: Array<{ orgId: string; name?: string; type?: string; typeLabel?: string; people: number; invitedVia?: string }>,
+  type = "",
+): Array<{ title: string; value: string; subtitle: string }> {
+  return companies
+    .filter((c) => !type || c.type === type)
+    .map((c) => ({
+      title: c.name || "Unnamed company",
+      value: c.orgId,
+      subtitle: [
+        c.typeLabel || c.type || "",
+        `${c.people} ${c.people === 1 ? "person" : "people"}`,
+        c.invitedVia ? `via ${c.invitedVia}` : "",
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    }));
+}
+
+/** "7 companies · 37 people · 1 company has not added anyone yet" */
+export function providerSummaryText(companies: Array<{ people: number }>): string {
+  const people = companies.reduce((n, c) => n + (c.people || 0), 0);
+  const idle = companies.filter((c) => !c.people).length;
+  return [
+    `${companies.length} ${companies.length === 1 ? "company" : "companies"}`,
+    `${people} ${people === 1 ? "person" : "people"}`,
+    idle ? `${idle} ${idle === 1 ? "company has" : "companies have"} not added anyone yet` : "",
+  ]
+    .filter(Boolean)
+    .join(" · ");
+}
+
 /** What an empty table says: nothing on site, nobody added yet, or the filters. */
 export function providerMembersEmptyText({
   companies,