@wikex/admin-kit 0.2.0 → 0.2.1

package/dist/chunk-JJLHSZ3T.js

@@ -0,0 +1,40 @@
+// src/project.ts
+var defineWikexProject = (project) => project;
+var normalizeGlobalScopes = (globals) => {
+  if (!globals) return /* @__PURE__ */ new Map();
+  if (Array.isArray(globals)) {
+    return new Map(globals.map((slug) => [slug, "content"]));
+  }
+  return new Map(Object.entries(globals));
+};
+var createVisualEditorRouteResolver = (registry) => {
+  const collections = new Set(registry.collections ?? []);
+  const globals = normalizeGlobalScopes(registry.globals);
+  return (pathname) => {
+    const collectionMatch = pathname.match(/\/collections\/([^/?#]+)\/([^/?#]+)/);
+    if (collectionMatch && collections.has(collectionMatch[1])) {
+      const collection = collectionMatch[1];
+      const rawDocumentID = decodeURIComponent(collectionMatch[2]);
+      return {
+        documentTarget: rawDocumentID === "create" ? null : { collection, documentID: rawDocumentID, kind: "collection" },
+        scope: "content",
+        type: "collection"
+      };
+    }
+    const globalMatch = pathname.match(/\/globals\/([^/?#]+)/);
+    const global = globalMatch?.[1];
+    if (global && globals.has(global)) {
+      return {
+        documentTarget: { global, kind: "global" },
+        scope: globals.get(global) ?? "content",
+        type: "global"
+      };
+    }
+    return null;
+  };
+};
+
+export {
+  defineWikexProject,
+  createVisualEditorRouteResolver
+};

package/dist/chunk-LC2CP5SR.js

@@ -0,0 +1,13 @@
+// src/rich-text/index.ts
+import { createServerFeature } from "@payloadcms/richtext-lexical";
+var TypographyFeature = createServerFeature({
+  feature: {
+    ClientFeature: "@wikex/admin-kit/rich-text/client#RichTextTypographyFeatureClient"
+  },
+  key: "wikexTypography"
+});
+var RichTextTypographyFeature = () => TypographyFeature();
+
+export {
+  RichTextTypographyFeature
+};

package/dist/chunk-LP22Y3NO.js

@@ -0,0 +1,61 @@
+import {
+  useAdminBrand
+} from "./chunk-XGKGKCQ6.js";
+
+// src/admin/Brand.tsx
+import Image from "next/image";
+import { jsx } from "react/jsx-runtime";
+var BrandLogo = ({
+  asset,
+  className,
+  height,
+  maxWidth
+}) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    className: ["brand-logo", className].filter(Boolean).join(" "),
+    style: { alignItems: "center", display: "inline-flex", height, maxWidth },
+    children: /* @__PURE__ */ jsx(
+      Image,
+      {
+        alt: "",
+        height: asset.height,
+        src: asset.url,
+        style: { height: "100%", maxWidth: "100%", objectFit: "contain", width: "auto" },
+        unoptimized: true,
+        width: asset.width
+      }
+    )
+  }
+);
+var AdminIcon = () => {
+  const brand = useAdminBrand();
+  return /* @__PURE__ */ jsx("span", { className: "aurea-brand aurea-brand--icon", children: /* @__PURE__ */ jsx(
+    BrandLogo,
+    {
+      asset: brand.logo,
+      className: "aurea-brand__image",
+      height: 32,
+      maxWidth: 32,
+      siteName: brand.siteName
+    }
+  ) });
+};
+var AdminLogo = () => {
+  const brand = useAdminBrand();
+  return /* @__PURE__ */ jsx("span", { "aria-label": brand.siteName, className: "aurea-brand aurea-brand--logo", role: "img", children: /* @__PURE__ */ jsx(
+    BrandLogo,
+    {
+      asset: brand.logo,
+      className: "aurea-brand__image",
+      height: 42,
+      maxWidth: 190,
+      siteName: brand.siteName
+    }
+  ) });
+};
+
+export {
+  AdminIcon,
+  AdminLogo
+};

package/dist/chunk-MDMKKWPU.js

@@ -0,0 +1,12 @@
+// src/admin/ViewSite.tsx
+import { ArrowUpRight } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var AdminViewSite = () => /* @__PURE__ */ jsxs("a", { className: "admin-view-site", "data-slot": "button", href: "/", rel: "noreferrer", target: "_blank", children: [
+  "Xem website",
+  /* @__PURE__ */ jsx(ArrowUpRight, { "aria-hidden": "true" })
+] });
+var ViewSite_default = AdminViewSite;
+
+export {
+  ViewSite_default
+};

package/dist/chunk-W4ZKDOWJ.js

@@ -0,0 +1,37 @@
+// src/admin/LogoutButton.tsx
+import { Link, useConfig, useTranslation } from "@payloadcms/ui";
+import { LogOut } from "lucide-react";
+import { formatAdminURL } from "payload/shared";
+import { jsx, jsxs } from "react/jsx-runtime";
+var AdminLogoutButton = ({ tabIndex = 0 }) => {
+  const {
+    config: {
+      admin: {
+        routes: { logout: logoutRoute }
+      },
+      routes: { admin: adminRoute }
+    }
+  } = useConfig();
+  const { t } = useTranslation();
+  const label = t("authentication:logOut");
+  return /* @__PURE__ */ jsxs(
+    Link,
+    {
+      "aria-label": label,
+      className: "admin-sign-out",
+      href: formatAdminURL({ adminRoute, path: logoutRoute }),
+      prefetch: false,
+      tabIndex,
+      title: label,
+      children: [
+        /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "admin-sign-out__icon", children: /* @__PURE__ */ jsx(LogOut, { strokeWidth: 2 }) }),
+        /* @__PURE__ */ jsx("span", { className: "admin-sign-out__label", children: label })
+      ]
+    }
+  );
+};
+var LogoutButton_default = AdminLogoutButton;
+
+export {
+  LogoutButton_default
+};

package/dist/chunk-XGKGKCQ6.js

@@ -0,0 +1,50 @@
+// src/admin/useAdminBrand.ts
+import { useEffect, useState } from "react";
+var defaultBrand = {
+  logo: { alt: "Wikex", height: 64, url: "/favicon.svg", width: 64 },
+  siteName: "Wikex"
+};
+var configureAdminBrand = (brand) => {
+  defaultBrand = brand;
+};
+var normalizeBrand = (settings) => {
+  const logo = settings?.logo;
+  const resolvedLogo = logo && typeof logo !== "number" && logo.url ? {
+    alt: logo.alt || settings?.siteName || defaultBrand.siteName,
+    height: logo.height || 64,
+    url: logo.updatedAt ? `${logo.url}?${encodeURIComponent(logo.updatedAt)}` : logo.url,
+    width: logo.width || 240
+  } : defaultBrand.logo;
+  return {
+    logo: resolvedLogo,
+    siteName: settings?.siteName?.trim() || defaultBrand.siteName
+  };
+};
+var useAdminBrand = () => {
+  const [brand, setBrand] = useState(() => normalizeBrand());
+  useEffect(() => {
+    const controller = new AbortController();
+    const loadBrand = async () => {
+      try {
+        const response = await fetch("/api/globals/settings?depth=1", {
+          cache: "no-store",
+          signal: controller.signal
+        });
+        if (!response.ok) return;
+        setBrand(normalizeBrand(await response.json()));
+      } catch (error) {
+        if (!(error instanceof DOMException && error.name === "AbortError")) {
+          console.error("Unable to load admin branding", error);
+        }
+      }
+    };
+    void loadBrand();
+    return () => controller.abort();
+  }, []);
+  return brand;
+};
+
+export {
+  configureAdminBrand,
+  useAdminBrand
+};

package/dist/chunk-YMBJCWN3.js

@@ -0,0 +1,73 @@
+import {
+  EDITABLE_PREVIEW_SELECTOR,
+  getEditableElementStyleKey,
+  getTextStyleCSS,
+  normalizeTextStyleMap
+} from "./chunk-BUD6BMFV.js";
+
+// src/TextStyleRuntime.tsx
+import { useEffect } from "react";
+var TextStyleRuntime = ({ styles }) => {
+  useEffect(() => {
+    const normalizedStyles = normalizeTextStyleMap(styles);
+    const originals = /* @__PURE__ */ new Map();
+    let applyFrame = 0;
+    const applyStyles = () => {
+      const fields = new Set(
+        document.querySelectorAll(`[data-wikex-field],${EDITABLE_PREVIEW_SELECTOR}`)
+      );
+      for (const element of fields) {
+        const fieldPath = element.dataset.wikexField || getEditableElementStyleKey(element);
+        if (!fieldPath || !normalizedStyles[fieldPath]) continue;
+        if (!originals.has(element)) {
+          originals.set(element, {
+            boxSizing: element.style.boxSizing,
+            fontFamily: element.style.fontFamily,
+            lineHeight: element.style.lineHeight,
+            marginLeft: element.style.marginLeft,
+            marginRight: element.style.marginRight,
+            maxWidth: element.style.maxWidth,
+            width: element.style.width
+          });
+        }
+        const style = getTextStyleCSS(normalizedStyles[fieldPath]);
+        element.style.boxSizing = style.boxSizing || "";
+        element.style.fontFamily = style.fontFamily || "";
+        element.style.lineHeight = style.lineHeight || "";
+        element.style.marginLeft = style.marginLeft || "";
+        element.style.marginRight = style.marginRight || "";
+        element.style.maxWidth = style.maxWidth || "";
+        element.style.width = style.width || "";
+      }
+    };
+    const scheduleApplyStyles = () => {
+      if (applyFrame) return;
+      applyFrame = window.requestAnimationFrame(() => {
+        applyFrame = 0;
+        applyStyles();
+      });
+    };
+    applyStyles();
+    const observer = new MutationObserver(scheduleApplyStyles);
+    observer.observe(document.body, { childList: true, subtree: true });
+    return () => {
+      observer.disconnect();
+      window.cancelAnimationFrame(applyFrame);
+      for (const [element, original] of originals) {
+        if (!element.isConnected) continue;
+        element.style.boxSizing = original.boxSizing;
+        element.style.fontFamily = original.fontFamily;
+        element.style.lineHeight = original.lineHeight;
+        element.style.marginLeft = original.marginLeft;
+        element.style.marginRight = original.marginRight;
+        element.style.maxWidth = original.maxWidth;
+        element.style.width = original.width;
+      }
+    };
+  }, [styles]);
+  return null;
+};
+
+export {
+  TextStyleRuntime
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from 'payload';
+export { VisualEditorRouteRegistry, WikexProjectDefinition, createVisualEditorRouteResolver, defineWikexProject } from './project.js';
+export { RichTextTypographyFeature } from './rich-text.js';
+export { TextStyleRuntime } from './text-style-runtime.js';
+export { EDITABLE_INTERACTIVE_SELECTOR, EDITABLE_PREVIEW_SELECTOR, TEXT_FONT_OPTIONS, TEXT_LINE_HEIGHT_OPTIONS, TextFontFamily, TextLineHeight, TextStyleMap, TextStyleValue, getEditableElementStyleKey, getTextStyleCSS, isSyntheticElementStyleKey, normalizeTextStyleMap, normalizeTextStyleValue } from './text-styles.js';
+import './runtimeConfig-BwjQepcW.js';
+import '@payloadcms/richtext-lexical';
+
+declare const IMAGE_UPLOAD_GUIDANCE = "Y\u00EAu c\u1EA7u \u0111\u1EC3 \u1EA3nh hi\u1EC3n th\u1ECB r\u00F5: hero/banner n\u00EAn t\u1EEB 1920 \u00D7 1080 px; \u1EA3nh n\u1ED9i dung n\u00EAn r\u1ED9ng t\u1ED1i thi\u1EC3u 1200 px. \u01AFu ti\u00EAn WebP ho\u1EB7c JPEG, dung l\u01B0\u1EE3ng d\u01B0\u1EDBi 500 KB.";
+declare const adminExperiencePlugin: Plugin;
+
+type WikexAdminPluginOptions = {
+    components?: {
+        beforeDashboard?: false | string;
+        provider?: false | string;
+    };
+    enabled?: boolean;
+};
+/**
+ * Reusable Payload admin shell. This plugin deliberately owns only generic admin
+ * behavior; project collections, globals and blocks are assembled separately by
+ * the project module registry.
+ */
+declare const wikexAdminPlugin: (options?: WikexAdminPluginOptions) => Plugin;
+
+export { IMAGE_UPLOAD_GUIDANCE, type WikexAdminPluginOptions, adminExperiencePlugin, wikexAdminPlugin };

package/dist/index.js

@@ -0,0 +1,44 @@
+import {
+  RichTextTypographyFeature
+} from "./chunk-LC2CP5SR.js";
+import {
+  TextStyleRuntime
+} from "./chunk-YMBJCWN3.js";
+import {
+  IMAGE_UPLOAD_GUIDANCE,
+  adminExperiencePlugin,
+  wikexAdminPlugin
+} from "./chunk-7FEACJUN.js";
+import {
+  createVisualEditorRouteResolver,
+  defineWikexProject
+} from "./chunk-JJLHSZ3T.js";
+import {
+  EDITABLE_INTERACTIVE_SELECTOR,
+  EDITABLE_PREVIEW_SELECTOR,
+  TEXT_FONT_OPTIONS,
+  TEXT_LINE_HEIGHT_OPTIONS,
+  getEditableElementStyleKey,
+  getTextStyleCSS,
+  isSyntheticElementStyleKey,
+  normalizeTextStyleMap,
+  normalizeTextStyleValue
+} from "./chunk-BUD6BMFV.js";
+export {
+  EDITABLE_INTERACTIVE_SELECTOR,
+  EDITABLE_PREVIEW_SELECTOR,
+  IMAGE_UPLOAD_GUIDANCE,
+  RichTextTypographyFeature,
+  TEXT_FONT_OPTIONS,
+  TEXT_LINE_HEIGHT_OPTIONS,
+  TextStyleRuntime,
+  adminExperiencePlugin,
+  createVisualEditorRouteResolver,
+  defineWikexProject,
+  getEditableElementStyleKey,
+  getTextStyleCSS,
+  isSyntheticElementStyleKey,
+  normalizeTextStyleMap,
+  normalizeTextStyleValue,
+  wikexAdminPlugin
+};

package/dist/live-preview.d.ts

@@ -0,0 +1,50 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { TextStyleValue } from './text-styles.js';
+import { V as VisualEditorDocumentTarget } from './runtimeConfig-BwjQepcW.js';
+export { B as BlockPickerOption, a as BlockPickerScope, L as LivePreviewRuntimeConfig, b as VisualEditorRoute, c as VisualEditorScope, d as configureLivePreview } from './runtimeConfig-BwjQepcW.js';
+
+declare const LivePreviewResizer: ({ children }: {
+    children?: React.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+type EditableGlobalScope = 'footer' | 'header' | 'settings';
+type GlobalInspectorSelection = {
+    fieldPath: string;
+    href?: string;
+    scope: EditableGlobalScope;
+    supportsLink: boolean;
+    text: string;
+};
+type GlobalFieldUpdate = {
+    path: string;
+    value: unknown;
+};
+type InspectorValues = {
+    backgroundColor: string;
+    text: string;
+    textColor: string;
+    url: string;
+};
+declare const readGlobal: (scope: EditableGlobalScope, signal?: AbortSignal) => Promise<Record<string, unknown>>;
+declare const updateGlobalFields: (scope: EditableGlobalScope, updates: GlobalFieldUpdate[]) => Promise<void>;
+declare const GlobalInlineInspector: ({ onApply, selection, }: {
+    onApply: (values: InspectorValues) => void;
+    selection: GlobalInspectorSelection;
+}) => react_jsx_runtime.JSX.Element;
+
+type TextInspectorSelection = VisualEditorDocumentTarget & {
+    canEditText: boolean;
+    fieldPath: string;
+    multiline: boolean;
+    tagName: string;
+    text: string;
+};
+declare const saveTextStylePatch: (selection: TextInspectorSelection, patch: TextStyleValue, signal?: AbortSignal) => Promise<TextStyleValue>;
+declare const TextStyleInspector: ({ onApply, onTextApply, selection, }: {
+    onApply: (values: TextStyleValue) => void;
+    onTextApply: (value: string) => void;
+    selection: TextInspectorSelection;
+}) => react_jsx_runtime.JSX.Element;
+
+export { type EditableGlobalScope, GlobalInlineInspector, type GlobalInspectorSelection, type InspectorValues, type TextInspectorSelection, TextStyleInspector, VisualEditorDocumentTarget, LivePreviewResizer as default, readGlobal, saveTextStylePatch, updateGlobalFields };

package/dist/live-preview.js

@@ -0,0 +1,19 @@
+import {
+  GlobalInlineInspector,
+  LivePreviewEditor_default,
+  TextStyleInspector,
+  configureLivePreview,
+  readGlobal,
+  saveTextStylePatch,
+  updateGlobalFields
+} from "./chunk-IL2CUCDG.js";
+import "./chunk-BUD6BMFV.js";
+export {
+  GlobalInlineInspector,
+  TextStyleInspector,
+  configureLivePreview,
+  LivePreviewEditor_default as default,
+  readGlobal,
+  saveTextStylePatch,
+  updateGlobalFields
+};

package/dist/project.d.ts

@@ -0,0 +1,34 @@
+import { c as VisualEditorScope, b as VisualEditorRoute } from './runtimeConfig-BwjQepcW.js';
+
+type WikexProjectDefinition<TModuleID extends string = string> = {
+    admin?: {
+        collectionOrder?: readonly string[];
+        globalOrder?: readonly string[];
+    };
+    brand: {
+        description: string;
+        logo: {
+            height: number;
+            url: string;
+            width: number;
+        };
+        name: string;
+    };
+    homepage?: {
+        defaultMode: 'builder' | 'preset';
+    };
+    id: string;
+    modules: readonly TModuleID[];
+};
+declare const defineWikexProject: <const TModuleID extends string, const TProject extends WikexProjectDefinition<TModuleID>>(project: TProject) => TProject;
+type VisualEditorRouteRegistry = {
+    collections?: readonly string[];
+    globals?: Readonly<Record<string, VisualEditorScope>> | readonly string[];
+};
+/**
+ * Creates the route adapter consumed by Live Preview without coupling the admin
+ * kit to collection names from a specific website.
+ */
+declare const createVisualEditorRouteResolver: (registry: VisualEditorRouteRegistry) => (pathname: string) => VisualEditorRoute | null;
+
+export { type VisualEditorRouteRegistry, type WikexProjectDefinition, createVisualEditorRouteResolver, defineWikexProject };

package/dist/project.js

@@ -0,0 +1,8 @@
+import {
+  createVisualEditorRouteResolver,
+  defineWikexProject
+} from "./chunk-JJLHSZ3T.js";
+export {
+  createVisualEditorRouteResolver,
+  defineWikexProject
+};

package/dist/rich-text-client.d.ts

@@ -0,0 +1,5 @@
+import * as _payloadcms_richtext_lexical from '@payloadcms/richtext-lexical';
+
+declare const RichTextTypographyFeatureClient: _payloadcms_richtext_lexical.FeatureProviderProviderClient<undefined, undefined>;
+
+export { RichTextTypographyFeatureClient };

package/dist/rich-text-client.js

@@ -0,0 +1,165 @@
+"use client";
+import {
+  TEXT_FONT_OPTIONS,
+  TEXT_LINE_HEIGHT_OPTIONS,
+  getTextStyleCSS,
+  normalizeTextStyleValue
+} from "./chunk-BUD6BMFV.js";
+
+// src/rich-text/client.tsx
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $forEachSelectedTextNode } from "@lexical/selection";
+import { createClientFeature } from "@payloadcms/richtext-lexical/client";
+import {
+  $getNodeByKey,
+  $getSelection,
+  $getState,
+  $isRangeSelection,
+  $isTextNode,
+  $setSelection,
+  $setState,
+  createState,
+  TextNode
+} from "lexical";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var fontFamilyState = createState("fontFamily", {
+  parse: (value) => normalizeTextStyleValue({ fontFamily: value }).fontFamily
+});
+var lineHeightState = createState("lineHeight", {
+  parse: (value) => normalizeTextStyleValue({ lineHeight: value }).lineHeight
+});
+var DEFAULT_TYPOGRAPHY = {
+  fontFamily: "default",
+  lineHeight: "default"
+};
+var readSelectedTypography = (editor) => editor.getEditorState().read(() => {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection)) return DEFAULT_TYPOGRAPHY;
+  const textNode = selection.getNodes().find($isTextNode);
+  if (!textNode) return DEFAULT_TYPOGRAPHY;
+  return {
+    fontFamily: $getState(textNode, fontFamilyState) ?? "default",
+    lineHeight: $getState(textNode, lineHeightState) ?? "default"
+  };
+});
+var updateSelectedTypography = (editor, property, value, savedSelection) => {
+  editor.update(() => {
+    if (!$isRangeSelection($getSelection()) && savedSelection) {
+      $setSelection(savedSelection.clone());
+    }
+    $forEachSelectedTextNode((textNode) => {
+      if (property === "fontFamily") {
+        const fontFamily = value;
+        $setState(textNode, fontFamilyState, fontFamily === "default" ? void 0 : fontFamily);
+      } else {
+        const lineHeight = value;
+        $setState(textNode, lineHeightState, lineHeight === "default" ? void 0 : lineHeight);
+      }
+    });
+  });
+};
+var TypographyToolbarItem = ({ editor }) => {
+  const [value, setValue] = useState(DEFAULT_TYPOGRAPHY);
+  const savedSelection = useRef(null);
+  const captureSelection = useCallback(() => {
+    editor.getEditorState().read(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) savedSelection.current = selection.clone();
+    });
+  }, [editor]);
+  useEffect(() => {
+    const syncValue = () => {
+      captureSelection();
+      setValue(readSelectedTypography(editor));
+    };
+    syncValue();
+    return editor.registerUpdateListener(syncValue);
+  }, [captureSelection, editor]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "aria-label": "Ki\u1EC3u ch\u1EEF",
+      className: "wikex-typography-selects",
+      onMouseDown: (event) => {
+        event.stopPropagation();
+        captureSelection();
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "select",
+          {
+            "aria-label": "Ph\xF4ng ch\u1EEF",
+            className: "wikex-minimal-select wikex-minimal-select--font",
+            onChange: (event) => {
+              const fontFamily = event.target.value;
+              setValue((current) => ({ ...current, fontFamily }));
+              updateSelectedTypography(editor, "fontFamily", fontFamily, savedSelection.current);
+            },
+            title: "Ph\xF4ng ch\u1EEF",
+            value: value.fontFamily,
+            children: TEXT_FONT_OPTIONS.map((option) => /* @__PURE__ */ jsx("option", { value: option.value, children: option.label }, option.value))
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "select",
+          {
+            "aria-label": "Chi\u1EC1u cao d\xF2ng",
+            className: "wikex-minimal-select wikex-minimal-select--line-height",
+            onChange: (event) => {
+              const lineHeight = event.target.value;
+              setValue((current) => ({ ...current, lineHeight }));
+              updateSelectedTypography(editor, "lineHeight", lineHeight, savedSelection.current);
+            },
+            title: "Chi\u1EC1u cao d\xF2ng",
+            value: value.lineHeight,
+            children: TEXT_LINE_HEIGHT_OPTIONS.map((option) => /* @__PURE__ */ jsx("option", { value: option.value, children: option.label }, option.value))
+          }
+        )
+      ]
+    }
+  );
+};
+var TypographyStatePlugin = () => {
+  const [editor] = useLexicalComposerContext();
+  useEffect(
+    () => editor.registerMutationListener(TextNode, (mutatedNodes) => {
+      editor.getEditorState().read(() => {
+        for (const [nodeKey, mutation] of mutatedNodes) {
+          if (mutation === "destroyed") continue;
+          const node = $getNodeByKey(nodeKey);
+          const element = editor.getElementByKey(nodeKey);
+          if (!$isTextNode(node) || !element) continue;
+          const style = getTextStyleCSS({
+            fontFamily: $getState(node, fontFamilyState),
+            lineHeight: $getState(node, lineHeightState)
+          });
+          if (style.fontFamily) element.style.fontFamily = style.fontFamily;
+          else element.style.removeProperty("font-family");
+          if (style.lineHeight) element.style.lineHeight = style.lineHeight;
+          else element.style.removeProperty("line-height");
+        }
+      });
+    }),
+    [editor]
+  );
+  return null;
+};
+var toolbarItem = {
+  Component: TypographyToolbarItem,
+  key: "wikex-typography-controls"
+};
+var typographyToolbarGroup = {
+  items: [toolbarItem],
+  key: "wikexTypography",
+  order: 34,
+  type: "buttons"
+};
+var RichTextTypographyFeatureClient = createClientFeature({
+  plugins: [{ Component: TypographyStatePlugin, position: "normal" }],
+  toolbarFixed: { groups: [typographyToolbarGroup] },
+  toolbarInline: { groups: [typographyToolbarGroup] }
+});
+export {
+  RichTextTypographyFeatureClient
+};

package/dist/rich-text.d.ts

@@ -0,0 +1,5 @@
+import * as _payloadcms_richtext_lexical from '@payloadcms/richtext-lexical';
+
+declare const RichTextTypographyFeature: () => _payloadcms_richtext_lexical.FeatureProviderServer<undefined, undefined, undefined>;
+
+export { RichTextTypographyFeature };

package/dist/rich-text.js

@@ -0,0 +1,6 @@
+import {
+  RichTextTypographyFeature
+} from "./chunk-LC2CP5SR.js";
+export {
+  RichTextTypographyFeature
+};