@bygghammar/cms-platform 0.80.1 → 0.90.0-m7.10

package/src/cms/edit-lock.ts

@@ -0,0 +1,491 @@
+/**
+ * Editing locks: the vocabulary shared by the database, the server cores and
+ * the browser.
+ *
+ * Nothing here talks to a database or to React. It is the one place that knows
+ * what a lock *means* — who holds it, whether it blocks you, how long a client
+ * may wait before saying so — so the server and the editor can never disagree
+ * about that.
+ */
+
+/** How long a lock survives without a heartbeat. */
+export const DEFAULT_LOCK_TTL_SECONDS = 120;
+
+/** Bounds the database enforces too, so a client cannot ask for a lock that outlives its editor. */
+export const MIN_LOCK_TTL_SECONDS = 15;
+export const MAX_LOCK_TTL_SECONDS = 3600;
+
+/**
+ * A resource an editor can hold open.
+ *
+ * `type` is a free-form, platform-level name — `"page"`, `"global_section"`,
+ * `"form"`, `"content_section"`, `"page_seo"` — deliberately not an enum, so a
+ * host with its own editable record type can lock it without patching the
+ * package or migrating the database.
+ */
+export type EditLockRef = {
+  resourceType: string;
+  resourceId: string;
+};
+
+/** What the server reports about one resource. */
+export type EditLockState = {
+  /** Somebody holds a live lock. */
+  locked: boolean;
+  /** That somebody is this caller, in this editing session. */
+  held: boolean;
+  /** The holder is this caller, but a different tab or window. */
+  sameUser?: boolean;
+  resourceType?: string;
+  resourceId?: string;
+  userId?: string | null;
+  userEmail?: string | null;
+  userName?: string | null;
+  /** @deprecated Bearer values are never returned by the server. */
+  sessionId?: string | null;
+  acquiredAt?: string | null;
+  refreshedAt?: string | null;
+  expiresAt?: string | null;
+  /** Database clock at the time of the reply, so clients need no clock of their own. */
+  now?: string | null;
+};
+
+/** Nothing is holding this resource. */
+export const FREE_EDIT_LOCK: EditLockState = { locked: false, held: false };
+
+/**
+ * Read a reply from the lock endpoint.
+ *
+ * A transport reply is security-relevant: an empty or malformed value must
+ * not be presented as proof that a resource is free. Missing migrations are
+ * converted to `FREE_EDIT_LOCK` explicitly by the server core before this
+ * boundary; every successful endpoint reply has both booleans.
+ */
+export function asEditLockState(data: unknown): EditLockState {
+  if (
+    data &&
+    typeof data === "object" &&
+    !Array.isArray(data) &&
+    typeof (data as Partial<EditLockState>).locked === "boolean" &&
+    typeof (data as Partial<EditLockState>).held === "boolean"
+  ) {
+    return data as EditLockState;
+  }
+  throw new TypeError(
+    "Invalid editing lock response: expected boolean locked and held fields",
+  );
+}
+
+/** A lock exists and it is not ours: editing and saving are both refused. */
+export function isBlocked(state: EditLockState | null | undefined): boolean {
+  return Boolean(state?.locked) && !state?.held;
+}
+
+/**
+ * Who to name in the message a blocked editor sees.
+ *
+ * Falls back through display name, email and finally a neutral phrase — a
+ * lock is still worth honouring when we cannot say whose it is.
+ */
+export function lockHolderLabel(
+  state: EditLockState | null | undefined,
+  fallback = "another user",
+): string {
+  const name = state?.userName?.trim();
+  if (name) return name;
+  const email = state?.userEmail?.trim();
+  if (email) return email;
+  return fallback;
+}
+
+/** One sentence explaining why the editor is read-only. */
+export function describeLock(state: EditLockState | null | undefined): string {
+  if (!isBlocked(state)) return "";
+  if (state?.sameUser) {
+    return "You already have this open in another tab. Finish there, or close it and try again after its lock expires.";
+  }
+  return `${lockHolderLabel(state)} is editing this right now. You can read it, but not change it.`;
+}
+
+/** Seconds until the lock lapses, measured against the server's own clock. */
+export function secondsRemaining(
+  state: EditLockState | null | undefined,
+): number | null {
+  const expires = state?.expiresAt ? Date.parse(state.expiresAt) : NaN;
+  if (Number.isNaN(expires)) return null;
+  const now = state?.now ? Date.parse(state.now) : Date.now();
+  return Math.max(
+    0,
+    Math.round((expires - (Number.isNaN(now) ? Date.now() : now)) / 1000),
+  );
+}
+
+/**
+ * Heartbeat interval for a given lifetime.
+ *
+ * A third of the TTL: two heartbeats can be lost — a sleeping tab, a flaky
+ * connection — before anyone else can take the resource, and a lock still
+ * lapses promptly once the editor really is gone.
+ */
+export function heartbeatIntervalMs(
+  ttlSeconds = DEFAULT_LOCK_TTL_SECONDS,
+): number {
+  return Math.max(5, Math.floor(clampTtl(ttlSeconds) / 3)) * 1000;
+}
+
+/** Keep a requested lifetime inside the bounds the database also applies. */
+export function clampTtl(ttlSeconds: number | undefined): number {
+  const n = Number.isFinite(ttlSeconds)
+    ? Number(ttlSeconds)
+    : DEFAULT_LOCK_TTL_SECONDS;
+  return Math.min(
+    MAX_LOCK_TTL_SECONDS,
+    Math.max(MIN_LOCK_TTL_SECONDS, Math.round(n)),
+  );
+}
+
+/**
+ * Identify one editing session — one tab, across reloads.
+ *
+ * Kept in `sessionStorage` because that is exactly the lifetime we want: a
+ * reload keeps its lock instead of locking the editor out of their own work,
+ * while a second tab gets its own id and is told about the first. Falls back
+ * to a per-call id where storage is unavailable (private windows, SSR).
+ */
+export function editSessionId(storageKey = "cms.edit-session"): string {
+  return readEditSessionId(storageKey).sessionId;
+}
+
+/**
+ * Make sure the stored editing-session id belongs to this live document.
+ *
+ * Browsers normally give each tab its own `sessionStorage`, but duplicating a
+ * tab (and some `window.open` flows) starts the new document with a copy. The
+ * copy must not use the old tab's session id: the server would otherwise see
+ * both tabs as the same lock holder and accept a stale save from either one.
+ *
+ * A browser-owned Web Lock proves whether the stored id already belongs to a
+ * live document without relying on that document being awake enough to answer.
+ * BroadcastChannel is the fallback for browsers without Web Locks. A reload
+ * has no other live owner and keeps its id; a copied tab gets a fresh id and
+ * writes it into its own copy of session storage. Without either browser API,
+ * reload continuity is preserved but a copied tab cannot be distinguished.
+ */
+export function claimEditSessionId(
+  storageKey = "cms.edit-session",
+): Promise<string> {
+  const candidate = readEditSessionId(storageKey);
+  const previous = liveEditSessions.get(storageKey);
+
+  // Every hook in one document shares one claim and one channel. If storage is
+  // unavailable there is nothing stable to compare, so the in-memory claim is
+  // the document's identity for the rest of its lifetime.
+  if (
+    previous &&
+    (!candidate.stored ||
+      (previous.sessionId === candidate.sessionId &&
+        previous.claimId === candidate.claimId))
+  ) {
+    return previous.ready;
+  }
+  previous?.close();
+
+  const contextId = freshEditSessionToken("ec_");
+  let channel: BroadcastChannel | null = null;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let removePageHideListener = () => {};
+  let releaseBrowserLock = () => {};
+  let closed = false;
+  let settled = false;
+  let resolveReady: (sessionId: string) => void = () => {};
+  const ready = new Promise<string>((resolve) => {
+    resolveReady = resolve;
+  });
+  const live: LiveEditSession = {
+    sessionId: candidate.sessionId,
+    claimId: candidate.claimId,
+    ready,
+    close: () => {
+      closed = true;
+      if (timer !== undefined) clearTimeout(timer);
+      removePageHideListener();
+      releaseBrowserLock();
+      try {
+        channel?.close();
+      } catch {
+        // A browser tearing the document down may already have closed it.
+      }
+      if (liveEditSessions.get(storageKey) === live) {
+        liveEditSessions.delete(storageKey);
+      }
+    },
+  };
+  liveEditSessions.set(storageKey, live);
+
+  if (typeof window !== "undefined") {
+    const onPageHide = (event: PageTransitionEvent) => {
+      // A real navigation/reload tears this document down before the new one
+      // probes, preventing the outgoing page from looking like a copied tab.
+      // A bfcache document remains the same live context and keeps listening.
+      if (!event.persisted) live.close();
+    };
+    window.addEventListener("pagehide", onPageHide);
+    removePageHideListener = () => {
+      window.removeEventListener("pagehide", onPageHide);
+    };
+  }
+
+  const finish = (collision: boolean) => {
+    if (settled) return;
+    settled = true;
+    if (timer !== undefined) clearTimeout(timer);
+    if (collision) rotate();
+    resolveReady(live.sessionId);
+  };
+
+  const rotate = () => {
+    const copied = { sessionId: live.sessionId, claimId: live.claimId };
+    const replacement = {
+      sessionId: freshEditSessionToken("es_"),
+      claimId: freshEditSessionToken("ec_"),
+    };
+    live.sessionId = replacement.sessionId;
+    live.claimId = replacement.claimId;
+    replaceStoredEditSession(storageKey, copied, replacement);
+  };
+
+  let broadcastStarted = false;
+  const startBroadcastClaim = () => {
+    if (broadcastStarted || closed || settled) return;
+    broadcastStarted = true;
+    try {
+      if (
+        typeof window === "undefined" ||
+        typeof window.BroadcastChannel === "undefined"
+      ) {
+        finish(false);
+        return;
+      }
+      channel = new window.BroadcastChannel(
+        `cms.edit-session-live:${storageKey}`,
+      );
+      channel.onmessage = (event: MessageEvent<unknown>) => {
+        const message = asEditSessionClaimMessage(event.data);
+        if (!message || message.contextId === contextId) return;
+
+        if (message.type === "probe" && message.claimId === live.claimId) {
+          try {
+            channel?.postMessage({
+              scope: EDIT_SESSION_CLAIM_SCOPE,
+              type: "occupied",
+              claimId: live.claimId,
+              contextId,
+              targetContextId: message.contextId,
+            } satisfies EditSessionClaimMessage);
+          } catch {
+            // The probing tab still has the timeout fallback.
+          }
+          return;
+        }
+
+        if (
+          message.type === "occupied" &&
+          message.targetContextId === contextId &&
+          message.claimId === live.claimId
+        ) {
+          finish(true);
+        }
+      };
+      channel.postMessage({
+        scope: EDIT_SESSION_CLAIM_SCOPE,
+        type: "probe",
+        claimId: live.claimId,
+        contextId,
+      } satisfies EditSessionClaimMessage);
+      // This fallback cannot prove absence: a frozen document may answer late.
+      // It is used only when the browser has no exclusive Web Locks primitive.
+      timer = setTimeout(() => finish(false), 50);
+    } catch {
+      finish(false);
+    }
+  };
+
+  let locks: LockManager | undefined;
+  try {
+    locks = typeof navigator !== "undefined" ? navigator.locks : undefined;
+  } catch {
+    // Privacy modes may expose Navigator while refusing individual APIs.
+  }
+  if (locks && typeof locks.request === "function") {
+    const requestBrowserLock = (attempt: number) => {
+      // The browser exposes held lock names through `navigator.locks.query()`.
+      // Use the copied, non-secret collision id — never the save bearer.
+      const name = `cms-edit-context:${storageKey}:${live.claimId}`;
+      try {
+        void locks
+          .request(name, { ifAvailable: true }, async (lock) => {
+            if (!lock) {
+              if (attempt >= 3) {
+                startBroadcastClaim();
+                return;
+              }
+              rotate();
+              requestBrowserLock(attempt + 1);
+              return;
+            }
+            finish(false);
+            await new Promise<void>((resolve) => {
+              if (closed) resolve();
+              else releaseBrowserLock = resolve;
+            });
+          })
+          .catch(() => startBroadcastClaim());
+      } catch {
+        startBroadcastClaim();
+      }
+    };
+    requestBrowserLock(0);
+  } else {
+    startBroadcastClaim();
+  }
+
+  return ready;
+}
+
+const EDIT_SESSION_CLAIM_SCOPE = "cms-edit-session-claim-v1";
+
+type EditSessionClaimMessage = {
+  scope: typeof EDIT_SESSION_CLAIM_SCOPE;
+  type: "probe" | "occupied";
+  claimId: string;
+  contextId: string;
+  targetContextId?: string;
+};
+
+type LiveEditSession = {
+  sessionId: string;
+  claimId: string;
+  ready: Promise<string>;
+  close: () => void;
+};
+
+const liveEditSessions = new Map<string, LiveEditSession>();
+
+function freshEditSessionToken(prefix: "es_" | "ec_"): string {
+  try {
+    if (
+      typeof crypto !== "undefined" &&
+      typeof crypto.randomUUID === "function"
+    ) {
+      return `${prefix}${crypto.randomUUID().replaceAll("-", "")}`;
+    }
+  } catch {
+    // Some privacy modes expose crypto but refuse calls into it.
+  }
+  return `${prefix}${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+
+function readEditSessionId(storageKey: string): {
+  sessionId: string;
+  claimId: string;
+  stored: boolean;
+} {
+  const claimStorageKey = `${storageKey}.claim`;
+  try {
+    const store = typeof sessionStorage === "undefined" ? null : sessionStorage;
+    if (!store) {
+      return {
+        sessionId: freshEditSessionToken("es_"),
+        claimId: freshEditSessionToken("ec_"),
+        stored: false,
+      };
+    }
+    const existing = store.getItem(storageKey);
+    if (existing && existing.trim()) {
+      const storedClaim = store.getItem(claimStorageKey);
+      const claimId =
+        storedClaim && storedClaim.trim()
+          ? storedClaim
+          : freshEditSessionToken("ec_");
+      if (!storedClaim?.trim()) store.setItem(claimStorageKey, claimId);
+      return { sessionId: existing, claimId, stored: true };
+    }
+    const next = freshEditSessionToken("es_");
+    const claimId = freshEditSessionToken("ec_");
+    store.setItem(storageKey, next);
+    store.setItem(claimStorageKey, claimId);
+    return { sessionId: next, claimId, stored: true };
+  } catch {
+    return {
+      sessionId: freshEditSessionToken("es_"),
+      claimId: freshEditSessionToken("ec_"),
+      stored: false,
+    };
+  }
+}
+
+function replaceStoredEditSession(
+  storageKey: string,
+  copied: { sessionId: string; claimId: string },
+  replacement: { sessionId: string; claimId: string },
+): void {
+  try {
+    const store = typeof sessionStorage === "undefined" ? null : sessionStorage;
+    // Do not overwrite a newer decision made by another caller in this same
+    // document while the asynchronous handshake was in flight.
+    if (
+      store?.getItem(storageKey) === copied.sessionId &&
+      store.getItem(`${storageKey}.claim`) === copied.claimId
+    ) {
+      store.setItem(storageKey, replacement.sessionId);
+      store.setItem(`${storageKey}.claim`, replacement.claimId);
+    }
+  } catch {
+    // The returned in-memory id still keeps this hook internally consistent.
+  }
+}
+
+function asEditSessionClaimMessage(
+  value: unknown,
+): EditSessionClaimMessage | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const message = value as Partial<EditSessionClaimMessage>;
+  if (
+    message.scope !== EDIT_SESSION_CLAIM_SCOPE ||
+    (message.type !== "probe" && message.type !== "occupied") ||
+    typeof message.claimId !== "string" ||
+    typeof message.contextId !== "string"
+  ) {
+    return null;
+  }
+  return message as EditSessionClaimMessage;
+}
+
+/**
+ * Resource-type names this package locks.
+ *
+ * Constants rather than an enum so a host can add one of its own — the
+ * database stores whatever string it is given — while everything shipped here
+ * agrees on the same spelling.
+ */
+export const EDIT_LOCK_TYPES = {
+  page: "page",
+  globalSection: "global_section",
+  form: "form",
+  formDefaults: "form_defaults",
+  contentSection: "content_section",
+  pageSeo: "page_seo",
+  siteSettings: "site_settings",
+} as const;
+
+export type EditLockType = (typeof EDIT_LOCK_TYPES)[keyof typeof EDIT_LOCK_TYPES];
+
+/** Message thrown when a save is refused because somebody else holds the lock. */
+export function lockedSaveMessage(
+  state: EditLockState | null | undefined,
+): string {
+  const who = state?.sameUser
+    ? "another of your own tabs"
+    : lockHolderLabel(state);
+  return `Not saved — ${who} is editing this. Reload to see the current version.`;
+}

package/src/config/modules.ts

@@ -0,0 +1,208 @@
+/**
+ * The CMS module table.
+ *
+ * "Modules" were previously described in four separate places that had to agree
+ * by hand: the `SiteFeatureFlags` type, the defaults object, the label map on
+ * the Modules screen, and the sidebar definitions. Adding one meant editing all
+ * four and hoping none was missed.
+ *
+ * This is the single description each of those now derives from. It is
+ * deliberately NOT a plugin registry: the key space stays a closed, typed union
+ * so an unknown value in `site_settings` is still rejected rather than trusted.
+ * What it buys is that a new first-party module is one entry here plus one line
+ * in the flag type, instead of five edits across the package.
+ */
+import type { ComponentType } from "react";
+import type { LucideProps } from "lucide-react";
+import {
+  Blocks,
+  Calendar,
+  ClipboardList,
+  GraduationCap,
+  MessageSquare,
+  MessageSquareQuote,
+} from "lucide-react";
+
+/**
+ * Every module a site can switch on.
+ *
+ * Adding a key here is the one type-level edit a new module needs; the compiler
+ * then requires the matching table entry below.
+ */
+export type SiteFeatureFlags = {
+  /** Trips / departures module (`/kontoret/trips`). */
+  trips: boolean;
+  /** Courses module (`/kontoret/kurser`). */
+  courses: boolean;
+  /** Reviews module (`/kontoret/recensioner`). */
+  reviews: boolean;
+  /** Transactional email + provider settings screens. */
+  email: boolean;
+  /** Head/body code injection and analytics pixels. */
+  tracking: boolean;
+  /** Backup & restore tooling (superadmin only). */
+  backup: boolean;
+  /** Custom domain management screen. */
+  domains: boolean;
+  /** Public forms module. */
+  forms: boolean;
+  /** Popups module: public popup runtime + backoffice administration. */
+  popups: boolean;
+};
+
+export type CmsModuleKey = keyof SiteFeatureFlags;
+
+/** A sidebar entry a module contributes when it is enabled. */
+export type CmsModuleNav = {
+  /** Appended to the site's configured backoffice path. Never hardcode `/kontoret`. */
+  readonly path: string;
+  readonly label: string;
+  readonly icon: ComponentType<LucideProps>;
+  readonly exact?: boolean;
+};
+
+export type CmsModuleDefinition = {
+  readonly key: CmsModuleKey;
+  /** Shown on the Modules screen. */
+  readonly label: string;
+  /** Whether a site that says nothing gets this module. */
+  readonly defaultEnabled: boolean;
+  /** One line of help on the Modules screen. */
+  readonly description?: string;
+  /**
+   * Sidebar contribution. Absent for modules whose screen belongs under Admin
+   * rather than in the sidebar — `email`, `tracking`, `backup` and `domains`.
+   */
+  readonly nav?: CmsModuleNav;
+  /**
+   * Minimum role for the module's own screens.
+   *
+   * This is not decoration: it has to name the same role the module's server
+   * functions actually demand. `admin` is used by modules whose writes call
+   * `has_role(user, 'admin')`, and `superadmin` by modules that can destroy or
+   * exfiltrate data. A module advertised to staff whose saves are refused sends
+   * an editor to a screen that cannot work.
+   */
+  readonly requiresRole?: "staff" | "admin" | "superadmin";
+  /**
+   * True when the module contributes a component to the public site. The public
+   * runtime host renders only the modules that both declare this and are
+   * enabled, so a disabled module mounts nothing.
+   */
+  readonly hasPublicRuntime?: boolean;
+};
+
+/**
+ * Every module, in sidebar order.
+ *
+ * `satisfies` pins the array to the flag union, so a key added to
+ * `SiteFeatureFlags` without an entry here — or an entry whose key is not a
+ * flag — is a compile error rather than a module that silently never appears.
+ */
+export const CMS_MODULES = [
+  {
+    key: "trips",
+    label: "Trips & departures",
+    defaultEnabled: false,
+    nav: { path: "/trips", label: "Trips", icon: Calendar },
+    requiresRole: "staff",
+  },
+  {
+    key: "courses",
+    label: "Courses",
+    defaultEnabled: false,
+    nav: { path: "/kurser", label: "Courses", icon: GraduationCap },
+    requiresRole: "staff",
+  },
+  {
+    key: "reviews",
+    label: "Reviews",
+    defaultEnabled: false,
+    nav: { path: "/recensioner", label: "Reviews", icon: MessageSquareQuote },
+    requiresRole: "staff",
+  },
+  { key: "email", label: "Transactional email", defaultEnabled: true, requiresRole: "staff" },
+  { key: "tracking", label: "Code & tracking", defaultEnabled: true, requiresRole: "admin" },
+  { key: "backup", label: "Backup & restore", defaultEnabled: true, requiresRole: "superadmin" },
+  {
+    key: "domains",
+    label: "Languages & domains",
+    defaultEnabled: false,
+    requiresRole: "admin",
+  },
+  {
+    key: "forms",
+    label: "Forms",
+    defaultEnabled: true,
+    nav: { path: "/forms", label: "Forms", icon: ClipboardList },
+    requiresRole: "staff",
+  },
+  {
+    key: "popups",
+    label: "Popups",
+    defaultEnabled: false,
+    description: "Timed popups on the public site, with their own statistics.",
+    nav: { path: "/popups", label: "Popups", icon: MessageSquare },
+    requiresRole: "staff",
+    hasPublicRuntime: true,
+  },
+] as const satisfies readonly CmsModuleDefinition[];
+
+/** Compile-time proof that every flag has exactly one module entry. */
+type DeclaredKeys = (typeof CMS_MODULES)[number]["key"];
+type MissingModule = Exclude<CmsModuleKey, DeclaredKeys>;
+type AssertNever<T extends never> = T;
+type _EveryFlagIsDeclared = AssertNever<MissingModule>;
+
+/**
+ * The table widened to the declaration type.
+ *
+ * `CMS_MODULES` is `as const` so the exhaustiveness check above can see the
+ * literal keys; consumers want the declared shape, where every optional field
+ * exists whether or not a particular entry uses it.
+ */
+export const CMS_MODULE_LIST: readonly CmsModuleDefinition[] = CMS_MODULES;
+
+export const CMS_MODULE_KEYS: readonly CmsModuleKey[] = CMS_MODULES.map((m) => m.key);
+
+export function findCmsModule(key: CmsModuleKey): CmsModuleDefinition | undefined {
+  return CMS_MODULES.find((module) => module.key === key);
+}
+
+/**
+ * Whether a viewer's platform roles satisfy a module's `requiresRole`.
+ *
+ * `staff` is not a row in `user_roles`: it is the host's own `is_staff` check,
+ * which anyone rendering the backoffice has already passed, so it is satisfied
+ * here. `admin` and `superadmin` are rows, and each has to be held in its own
+ * right — the server asks `has_role(user, 'admin')`, and that question is not
+ * answered by holding some other, higher-sounding role. Inferring one from the
+ * other here would put an editable screen in front of someone whose every save
+ * the server then refuses.
+ */
+export function moduleRoleSatisfied(
+  requiresRole: CmsModuleDefinition["requiresRole"],
+  roles: readonly string[],
+): boolean {
+  if (requiresRole === "admin" || requiresRole === "superadmin") {
+    return roles.includes(requiresRole);
+  }
+  return true;
+}
+
+/** The defaults a site starts from, derived so the two can never disagree. */
+export const DEFAULT_FEATURE_FLAGS: SiteFeatureFlags = Object.fromEntries(
+  CMS_MODULES.map((module) => [module.key, module.defaultEnabled]),
+) as SiteFeatureFlags;
+
+/** Labels for the Modules screen, derived from the same table. */
+export const CMS_MODULE_LABELS: Readonly<Record<CmsModuleKey, string>> = Object.fromEntries(
+  CMS_MODULES.map((module) => [module.key, module.label]),
+) as Record<CmsModuleKey, string>;
+
+/**
+ * Blocks that unnecessary icon imports are not the reason a public bundle grows:
+ * this module table is imported by the public runtime host as well, so keep it
+ * free of anything heavier than the icon components already used by the sidebar.
+ */
+export type { LucideProps };