@larose-ui/enterprise 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 laRose contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.css

@@ -0,0 +1,62 @@
+/* src/audit/AuditHistory.module.css */
+.panel {
+  border: 1px solid var(--lr-color-border);
+  border-radius: var(--lr-radius-md);
+  padding: var(--lr-space-3);
+  background: var(--lr-color-surface-elevated);
+}
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: var(--lr-space-2);
+}
+.header button {
+  border: none;
+  background: none;
+  font-size: 1.25rem;
+  cursor: pointer;
+  line-height: 1;
+}
+.empty {
+  margin: 0;
+  color: var(--lr-color-text-muted);
+  font-size: var(--lr-font-size-sm);
+}
+.list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.list li {
+  padding: var(--lr-space-2) 0;
+  border-bottom: 1px solid var(--lr-color-border);
+}
+.list li:last-child {
+  border-bottom: none;
+}
+.change {
+  font-weight: var(--lr-font-weight-medium);
+}
+.meta {
+  font-size: var(--lr-font-size-sm);
+  color: var(--lr-color-text-muted);
+  margin-top: var(--lr-space-1);
+}
+
+/* src/audit/AuditedInput.module.css */
+.wrapper {
+  display: flex;
+  flex-direction: column;
+  gap: var(--lr-space-2);
+}
+.historyButton {
+  align-self: flex-start;
+  font-size: var(--lr-font-size-sm);
+  color: var(--lr-color-primary);
+  background: none;
+  border: none;
+  cursor: pointer;
+  padding: 0;
+  text-decoration: underline;
+}

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { InputProps } from '@larose-ui/react';
+import { VersionInfo } from '@larose-ui/core';
+import { FormFieldSchema, FormSchema } from '@larose-ui/forms';
+
+interface AuditEntry {
+    id: string;
+    field: string;
+    actor: string;
+    before: string;
+    after: string;
+    timestamp: string;
+    resourceId?: string;
+}
+interface AuditContextValue {
+    actor: string;
+    entries: AuditEntry[];
+    recordChange: (entry: Omit<AuditEntry, 'id' | 'timestamp' | 'actor'>) => void;
+    getHistory: (field: string, resourceId?: string) => AuditEntry[];
+}
+
+interface AuditProviderProps {
+    actor?: string;
+    children: ReactNode;
+}
+declare function AuditProvider({ actor, children }: AuditProviderProps): react.JSX.Element;
+declare function useAudit(): AuditContextValue;
+declare function useOptionalAudit(): AuditContextValue | null;
+
+interface AuditedInputProps extends Omit<InputProps, 'onChange'> {
+    field: string;
+    resourceId?: string;
+    showHistory?: boolean;
+    onChange?: (value: string) => void;
+}
+declare function AuditedInput({ field, resourceId, showHistory, value, defaultValue, onChange, ...props }: AuditedInputProps): react.JSX.Element;
+
+interface AuditHistoryProps {
+    field: string;
+    resourceId?: string;
+    onClose?: () => void;
+}
+declare function AuditHistory({ field, resourceId, onClose }: AuditHistoryProps): react.JSX.Element;
+
+interface VersionCheckOptions {
+    frontend?: string;
+    backend?: string;
+    minBackend?: string;
+    maxBackend?: string;
+    deprecatedFeatures?: string[];
+    requiredFeatures?: string[];
+}
+declare function checkVersionCompatibility(options: VersionCheckOptions): VersionInfo;
+
+interface VersionProviderProps extends VersionCheckOptions {
+    children: ReactNode;
+    showBanner?: boolean;
+}
+declare function VersionProvider({ children, showBanner, ...options }: VersionProviderProps): react.JSX.Element;
+declare function useVersion(): VersionInfo;
+declare function useOptionalVersion(): VersionInfo | null;
+
+type UISchemaType = 'form' | 'page' | 'table';
+interface UISchemaField {
+    type: FormFieldSchema['type'];
+    name: string;
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    hint?: string;
+    permission?: string;
+    options?: FormFieldSchema['options'];
+    showWhen?: FormFieldSchema['showWhen'];
+}
+interface UISchema {
+    type: UISchemaType;
+    id: string;
+    title?: string;
+    permission?: string;
+    fields?: UISchemaField[];
+    submitUrl?: string;
+}
+declare function compileFormSchema(schema: UISchema): FormSchema;
+declare function validateUISchema(schema: UISchema): string[];
+
+interface SchemaRendererProps {
+    schema: UISchema;
+    onSubmit?: (values: Record<string, string>) => Promise<void> | void;
+}
+declare function SchemaRenderer({ schema, onSubmit }: SchemaRendererProps): react.JSX.Element;
+
+interface SensitiveActionProps {
+    label: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    requireProductionConfirm?: boolean;
+    onConfirm: () => void | Promise<void>;
+}
+declare function SensitiveAction({ label, description, confirmLabel, cancelLabel, requireProductionConfirm, onConfirm, }: SensitiveActionProps): react.JSX.Element;
+
+interface SessionGuardProps {
+    children: ReactNode;
+    onSessionExpired?: (returnUrl: string) => void;
+    loginUrl?: string;
+}
+declare function SessionGuard({ children, onSessionExpired, loginUrl, }: SessionGuardProps): react.JSX.Element;
+declare function notifySessionExpired(code?: number): void;
+
+export { type AuditContextValue, type AuditEntry, AuditHistory, type AuditHistoryProps, AuditProvider, type AuditProviderProps, AuditedInput, type AuditedInputProps, SchemaRenderer, type SchemaRendererProps, SensitiveAction, type SensitiveActionProps, SessionGuard, type SessionGuardProps, type UISchema, type UISchemaField, type UISchemaType, type VersionCheckOptions, VersionProvider, type VersionProviderProps, checkVersionCompatibility, compileFormSchema, notifySessionExpired, useAudit, useOptionalAudit, useOptionalVersion, useVersion, validateUISchema };

package/dist/index.js

@@ -0,0 +1,392 @@
+// src/audit/AuditProvider.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var AuditContext = createContext(null);
+function AuditProvider({ actor = "system", children }) {
+  const [entries, setEntries] = useState([]);
+  const recordChange = useCallback(
+    (entry) => {
+      setEntries((prev) => [
+        {
+          ...entry,
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          actor,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        ...prev
+      ]);
+    },
+    [actor]
+  );
+  const getHistory = useCallback(
+    (field, resourceId) => entries.filter(
+      (e) => e.field === field && (resourceId === void 0 || e.resourceId === resourceId)
+    ),
+    [entries]
+  );
+  const value = useMemo(
+    () => ({ actor, entries, recordChange, getHistory }),
+    [actor, entries, recordChange, getHistory]
+  );
+  return /* @__PURE__ */ jsx(AuditContext.Provider, { value, children });
+}
+function useAudit() {
+  const ctx = useContext(AuditContext);
+  if (!ctx) {
+    throw new Error("useAudit must be used within AuditProvider");
+  }
+  return ctx;
+}
+function useOptionalAudit() {
+  return useContext(AuditContext);
+}
+
+// src/audit/AuditedInput.tsx
+import { useState as useState2 } from "react";
+import { Input } from "@larose-ui/react";
+import { useOptionalObservability } from "@larose-ui/observability";
+
+// src/audit/AuditHistory.module.css
+var AuditHistory_default = {};
+
+// src/audit/AuditHistory.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function AuditHistory({ field, resourceId, onClose }) {
+  const { getHistory } = useAudit();
+  const history = getHistory(field, resourceId);
+  return /* @__PURE__ */ jsxs("aside", { className: AuditHistory_default.panel, "aria-label": `Audit history for ${field}`, children: [
+    /* @__PURE__ */ jsxs("header", { className: AuditHistory_default.header, children: [
+      /* @__PURE__ */ jsxs("strong", { children: [
+        field,
+        " history"
+      ] }),
+      onClose && /* @__PURE__ */ jsx2("button", { type: "button", onClick: onClose, "aria-label": "Close history", children: "\xD7" })
+    ] }),
+    history.length === 0 ? /* @__PURE__ */ jsx2("p", { className: AuditHistory_default.empty, children: "No changes recorded." }) : /* @__PURE__ */ jsx2("ul", { className: AuditHistory_default.list, children: history.map((entry) => /* @__PURE__ */ jsxs("li", { children: [
+      /* @__PURE__ */ jsxs("div", { className: AuditHistory_default.change, children: [
+        entry.before || "(empty)",
+        " \u2192 ",
+        entry.after || "(empty)"
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: AuditHistory_default.meta, children: [
+        "Changed by ",
+        entry.actor,
+        " \xB7 ",
+        new Date(entry.timestamp).toLocaleString()
+      ] })
+    ] }, entry.id)) })
+  ] });
+}
+
+// src/audit/AuditedInput.module.css
+var AuditedInput_default = {};
+
+// src/audit/AuditedInput.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function AuditedInput({
+  field,
+  resourceId,
+  showHistory = true,
+  value,
+  defaultValue,
+  onChange,
+  ...props
+}) {
+  const audit = useOptionalAudit();
+  const observability = useOptionalObservability();
+  const [internal, setInternal] = useState2(String(defaultValue ?? ""));
+  const [historyOpen, setHistoryOpen] = useState2(false);
+  const current = value !== void 0 ? String(value) : internal;
+  const handleChange = (e) => {
+    const next = e.target.value;
+    const previous = current;
+    if (audit && previous !== next) {
+      audit.recordChange({ field, before: previous, after: next, resourceId });
+    }
+    observability?.track({
+      type: "interaction",
+      component: "AuditedInput",
+      metadata: { field, resourceId, action: "change" }
+    });
+    if (value === void 0) setInternal(next);
+    onChange?.(next);
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: AuditedInput_default.wrapper, "data-lr-audited-field": field, children: [
+    /* @__PURE__ */ jsx3(Input, { ...props, value: current, onChange: handleChange }),
+    showHistory && audit && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: AuditedInput_default.historyButton,
+          onClick: () => setHistoryOpen((v) => !v),
+          children: "View History"
+        }
+      ),
+      historyOpen && /* @__PURE__ */ jsx3(AuditHistory, { field, resourceId, onClose: () => setHistoryOpen(false) })
+    ] })
+  ] });
+}
+
+// src/version/checkVersion.ts
+import { LAROSE_VERSION } from "@larose-ui/core";
+function parseMajor(version) {
+  const match = version.match(/^(\d+)/);
+  return match ? Number(match[1]) : 0;
+}
+function checkVersionCompatibility(options) {
+  const frontend = options.frontend ?? LAROSE_VERSION;
+  const backend = options.backend;
+  const warnings = [];
+  let compatible = true;
+  if (backend && options.minBackend) {
+    if (parseMajor(backend) < parseMajor(options.minBackend)) {
+      compatible = false;
+      warnings.push(
+        `Backend v${backend} is below minimum v${options.minBackend}. Some features may be unavailable.`
+      );
+    }
+  }
+  if (backend && options.maxBackend) {
+    if (parseMajor(backend) > parseMajor(options.maxBackend)) {
+      compatible = false;
+      warnings.push(
+        `Backend v${backend} exceeds supported maximum v${options.maxBackend}. Application update required.`
+      );
+    }
+  }
+  for (const feature of options.requiredFeatures ?? []) {
+    if (options.deprecatedFeatures?.includes(feature)) {
+      compatible = false;
+      warnings.push(`Feature "${feature}" requires an application update.`);
+    }
+  }
+  for (const deprecated of options.deprecatedFeatures ?? []) {
+    warnings.push(`API "${deprecated}" is deprecated and may be removed.`);
+  }
+  return { frontend, backend, compatible, warnings };
+}
+
+// src/version/VersionProvider.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useMemo as useMemo2
+} from "react";
+import { Alert } from "@larose-ui/react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var VersionContext = createContext2(null);
+function VersionProvider({
+  children,
+  showBanner = true,
+  ...options
+}) {
+  const info = useMemo2(
+    () => checkVersionCompatibility(options),
+    [
+      options.frontend,
+      options.backend,
+      options.minBackend,
+      options.maxBackend,
+      options.deprecatedFeatures?.join(","),
+      options.requiredFeatures?.join(",")
+    ]
+  );
+  return /* @__PURE__ */ jsxs3(VersionContext.Provider, { value: info, children: [
+    showBanner && !info.compatible && /* @__PURE__ */ jsx4(Alert, { variant: "warning", title: "Version mismatch", children: info.warnings[0] ?? "This feature requires an application update." }),
+    children
+  ] });
+}
+function useVersion() {
+  const ctx = useContext2(VersionContext);
+  if (!ctx) {
+    throw new Error("useVersion must be used within VersionProvider");
+  }
+  return ctx;
+}
+function useOptionalVersion() {
+  return useContext2(VersionContext);
+}
+
+// src/schema/uiSchema.ts
+function compileFormSchema(schema) {
+  if (schema.type !== "form") {
+    throw new Error(`Expected form schema, got "${schema.type}"`);
+  }
+  return {
+    id: schema.id,
+    title: schema.title,
+    fields: (schema.fields ?? []).map((field) => ({
+      name: field.name,
+      type: field.type,
+      label: field.label ?? field.name,
+      placeholder: field.placeholder,
+      required: field.required,
+      hint: field.hint,
+      options: field.options,
+      showWhen: field.showWhen
+    }))
+  };
+}
+function validateUISchema(schema) {
+  const errors = [];
+  if (!schema.id) errors.push("Schema id is required");
+  if (!schema.type) errors.push("Schema type is required");
+  if (schema.type === "form" && (!schema.fields || schema.fields.length === 0)) {
+    errors.push("Form schema requires at least one field");
+  }
+  for (const field of schema.fields ?? []) {
+    if (!field.name) errors.push("Field name is required");
+    if (!field.type) errors.push(`Field "${field.name}" requires a type`);
+  }
+  return errors;
+}
+
+// src/schema/SchemaRenderer.tsx
+import { Form } from "@larose-ui/forms";
+import { Can } from "@larose-ui/permissions";
+import { Alert as Alert2 } from "@larose-ui/react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function SchemaRenderer({ schema, onSubmit }) {
+  const errors = validateUISchema(schema);
+  if (errors.length > 0) {
+    return /* @__PURE__ */ jsx5(Alert2, { variant: "error", title: "Invalid UI schema", children: /* @__PURE__ */ jsx5("ul", { style: { margin: 0, paddingInlineStart: "1.25rem" }, children: errors.map((e) => /* @__PURE__ */ jsx5("li", { children: e }, e)) }) });
+  }
+  if (schema.type !== "form") {
+    return /* @__PURE__ */ jsx5(Alert2, { variant: "info", title: "Schema type not rendered", children: "Page and table schemas are composed at the app layer. Use compileFormSchema for forms." });
+  }
+  const formSchema = compileFormSchema(schema);
+  const form = /* @__PURE__ */ jsx5(
+    Form,
+    {
+      schema: formSchema,
+      submitUrl: schema.submitUrl,
+      onSubmit,
+      submitLabel: "Save"
+    }
+  );
+  if (schema.permission) {
+    return /* @__PURE__ */ jsx5(Can, { permission: schema.permission, fallback: "forbidden", children: form });
+  }
+  return form;
+}
+
+// src/security/SensitiveAction.tsx
+import { useCallback as useCallback2, useState as useState3 } from "react";
+import { Dialog, Button } from "@larose-ui/react";
+import { useEnvironment } from "@larose-ui/runtime";
+import { useOptionalObservability as useOptionalObservability2 } from "@larose-ui/observability";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function SensitiveAction({
+  label,
+  description = "This action may have irreversible consequences.",
+  confirmLabel = "Confirm",
+  cancelLabel = "Cancel",
+  requireProductionConfirm = true,
+  onConfirm
+}) {
+  const [open, setOpen] = useState3(false);
+  const [busy, setBusy] = useState3(false);
+  const environment = useEnvironment();
+  const observability = useOptionalObservability2();
+  const isProduction = environment === "production";
+  const handleConfirm = useCallback2(async () => {
+    setBusy(true);
+    try {
+      observability?.track({
+        type: "interaction",
+        component: "SensitiveAction",
+        metadata: { label, environment }
+      });
+      await onConfirm();
+      setOpen(false);
+    } finally {
+      setBusy(false);
+    }
+  }, [environment, label, observability, onConfirm]);
+  return /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsx6(Button, { variant: "destructive", onClick: () => setOpen(true), children: label }),
+    /* @__PURE__ */ jsx6(
+      Dialog,
+      {
+        open,
+        onClose: () => setOpen(false),
+        title: label,
+        description: isProduction && requireProductionConfirm ? `${description} You are in production.` : description,
+        confirmLabel,
+        cancelLabel,
+        onConfirm: () => void handleConfirm(),
+        loading: busy,
+        variant: "destructive"
+      }
+    )
+  ] });
+}
+
+// src/security/SessionGuard.tsx
+import { useCallback as useCallback3, useEffect, useState as useState4 } from "react";
+import { Dialog as Dialog2 } from "@larose-ui/react";
+import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function SessionGuard({
+  children,
+  onSessionExpired,
+  loginUrl = "/login"
+}) {
+  const [expired, setExpired] = useState4(false);
+  useEffect(() => {
+    const handler = (event) => {
+      const detail = event.detail;
+      if (detail?.code === 401) setExpired(true);
+    };
+    window.addEventListener("larose:session-expired", handler);
+    return () => window.removeEventListener("larose:session-expired", handler);
+  }, []);
+  const handleRedirect = useCallback3(() => {
+    const returnUrl = window.location.pathname + window.location.search;
+    onSessionExpired?.(returnUrl);
+    window.location.href = `${loginUrl}?returnUrl=${encodeURIComponent(returnUrl)}`;
+  }, [loginUrl, onSessionExpired]);
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    children,
+    /* @__PURE__ */ jsx7(
+      Dialog2,
+      {
+        open: expired,
+        onClose: () => setExpired(false),
+        title: "Session expired",
+        description: "Your session has expired. Sign in again to continue.",
+        confirmLabel: "Sign in",
+        cancelLabel: "Dismiss",
+        onConfirm: handleRedirect
+      }
+    )
+  ] });
+}
+function notifySessionExpired(code = 401) {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent("larose:session-expired", { detail: { code } }));
+  }
+}
+export {
+  AuditHistory,
+  AuditProvider,
+  AuditedInput,
+  SchemaRenderer,
+  SensitiveAction,
+  SessionGuard,
+  VersionProvider,
+  checkVersionCompatibility,
+  compileFormSchema,
+  notifySessionExpired,
+  useAudit,
+  useOptionalAudit,
+  useOptionalVersion,
+  useVersion,
+  validateUISchema
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@larose-ui/enterprise",
+  "version": "0.1.0",
+  "description": "Enterprise features — audit trails, version compatibility, UI schema IaC, security patterns",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@larose-ui/core": "0.1.0",
+    "@larose-ui/permissions": "0.1.0",
+    "@larose-ui/observability": "0.1.0",
+    "@larose-ui/forms": "0.1.0",
+    "@larose-ui/react": "0.1.0",
+    "@larose-ui/runtime": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@vitejs/plugin-react": "^4.3.4",
+    "jsdom": "^25.0.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/larose-ui/larose.git",
+    "directory": "packages/enterprise"
+  },
+  "keywords": [
+    "larose",
+    "react",
+    "ui-platform",
+    "design-system",
+    "saas"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}