@payloadcms/richtext-lexical 3.0.0-beta.6 → 3.0.0-beta.60

package/dist/utilities/createClientFeature.d.ts

@@ -0,0 +1,13 @@
+import type React from 'react';
+import type { ClientComponentProps, ClientFeature, ClientFeatureProviderMap, ResolvedClientFeatureMap } from '../features/typesClient.js';
+import type { ClientEditorConfig } from '../lexical/config/types.js';
+export type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> = ((props: {
+    clientFunctions: Record<string, any>;
+    /** unSanitizedEditorConfig.features, but mapped */
+    featureProviderMap: ClientFeatureProviderMap;
+    props: ClientComponentProps<UnSanitizedClientProps>;
+    resolvedFeatures: ResolvedClientFeatureMap;
+    unSanitizedEditorConfig: ClientEditorConfig;
+}) => ClientFeature<ClientProps>) | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>;
+export declare const createClientFeature: <UnSanitizedClientProps = undefined, ClientProps = UnSanitizedClientProps>(args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>) => React.FC<ClientComponentProps<ClientProps>>;
+//# sourceMappingURL=createClientFeature.d.ts.map

package/dist/utilities/createClientFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClientFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createClientFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,wBAAwB,EAGxB,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAIpE,MAAM,MAAM,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,IACnE,CAAC,CAAC,KAAK,EAAE;IACP,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACpC,mDAAmD;IACnD,kBAAkB,EAAE,wBAAwB,CAAA;IAC5C,KAAK,EAAE,oBAAoB,CAAC,sBAAsB,CAAC,CAAA;IAEnD,gBAAgB,EAAE,wBAAwB,CAAA;IAE1C,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,KAAK,aAAa,CAAC,WAAW,CAAC,CAAC,GACjC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;AAEnE,eAAO,MAAM,mBAAmB,EAAE,CAChC,sBAAsB,GAAG,SAAS,EAClC,WAAW,GAAG,sBAAsB,EAEpC,IAAI,EAAE,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,CAAC,KAC/D,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAmC9C,CAAA"}

package/dist/utilities/createClientFeature.js

@@ -0,0 +1,30 @@
+import { createClientComponent } from '../features/createClientComponent.js';
+export const createClientFeature = (feature)=>{
+    const featureProviderProvideClient = (props)=>{
+        const featureProviderClient = {
+            clientFeatureProps: props
+        };
+        if (typeof feature === 'function') {
+            featureProviderClient.feature = ({ clientFunctions, featureProviderMap, resolvedFeatures, unSanitizedEditorConfig })=>{
+                const toReturn = feature({
+                    clientFunctions,
+                    featureProviderMap,
+                    props,
+                    resolvedFeatures,
+                    unSanitizedEditorConfig
+                });
+                if (toReturn.sanitizedClientFeatureProps === null) {
+                    toReturn.sanitizedClientFeatureProps = props;
+                }
+                return toReturn;
+            };
+        } else {
+            feature.sanitizedClientFeatureProps = props;
+            featureProviderClient.feature = feature;
+        }
+        return featureProviderClient;
+    };
+    return createClientComponent(featureProviderProvideClient);
+};
+
+//# sourceMappingURL=createClientFeature.js.map

package/dist/utilities/createClientFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type React from 'react'\n\nimport type {\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  ResolvedClientFeatureMap,\n} from '../features/typesClient.js'\nimport type { ClientEditorConfig } from '../lexical/config/types.js'\n\nimport { createClientComponent } from '../features/createClientComponent.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      clientFunctions: Record<string, any>\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      props: ClientComponentProps<UnSanitizedClientProps>\n      // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n      resolvedFeatures: ResolvedClientFeatureMap\n      // unSanitized EditorConfig,\n      unSanitizedEditorConfig: ClientEditorConfig\n    }) => ClientFeature<ClientProps>)\n  | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>\n\nexport const createClientFeature: <\n  UnSanitizedClientProps = undefined,\n  ClientProps = UnSanitizedClientProps,\n>(\n  args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>,\n) => React.FC<ClientComponentProps<ClientProps>> = (feature) => {\n  const featureProviderProvideClient: FeatureProviderProviderClient<any, any> = (props) => {\n    const featureProviderClient: Partial<FeatureProviderClient<any, any>> = {\n      clientFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderClient.feature = ({\n        clientFunctions,\n        featureProviderMap,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          clientFunctions,\n          featureProviderMap,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedClientFeatureProps === null) {\n          toReturn.sanitizedClientFeatureProps = props\n        }\n\n        return toReturn\n      }\n    } else {\n      ;(feature as ClientFeature<any>).sanitizedClientFeatureProps = props\n      featureProviderClient.feature = feature as ClientFeature<any>\n    }\n    return featureProviderClient as FeatureProviderClient<any, any>\n  }\n\n  return createClientComponent(featureProviderProvideClient)\n}\n"],"names":["createClientComponent","createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","clientFunctions","featureProviderMap","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps"],"mappings":"AAYA,SAASA,qBAAqB,QAAQ,uCAAsC;AAe5E,OAAO,MAAMC,sBAKsC,CAACC;IAClD,MAAMC,+BAAwE,CAACC;QAC7E,MAAMC,wBAAkE;YACtEC,oBAAoBF;QACtB;QAEA,IAAI,OAAOF,YAAY,YAAY;YACjCG,sBAAsBH,OAAO,GAAG,CAAC,EAC/BK,eAAe,EACfC,kBAAkB,EAClBC,gBAAgB,EAChBC,uBAAuB,EACxB;gBACC,MAAMC,WAAWT,QAAQ;oBACvBK;oBACAC;oBACAJ;oBACAK;oBACAC;gBACF;gBAEA,IAAIC,SAASC,2BAA2B,KAAK,MAAM;oBACjDD,SAASC,2BAA2B,GAAGR;gBACzC;gBAEA,OAAOO;YACT;QACF,OAAO;YACHT,QAA+BU,2BAA2B,GAAGR;YAC/DC,sBAAsBH,OAAO,GAAGA;QAClC;QACA,OAAOG;IACT;IAEA,OAAOL,sBAAsBG;AAC/B,EAAC"}

package/dist/utilities/createServerFeature.d.ts

@@ -0,0 +1,16 @@
+import type { SanitizedConfig } from 'payload';
+import type { FeatureProviderProviderServer, FeatureProviderServer, ResolvedServerFeatureMap, ServerFeature, ServerFeatureProviderMap } from '../features/typesServer.js';
+import type { ServerEditorConfig } from '../lexical/config/types.js';
+export type CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps> = Pick<FeatureProviderServer<UnSanitizedProps, ClientProps>, 'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'> & {
+    feature: ((props: {
+        config: SanitizedConfig;
+        /** unSanitizedEditorConfig.features, but mapped */
+        featureProviderMap: ServerFeatureProviderMap;
+        isRoot?: boolean;
+        props: UnSanitizedProps;
+        resolvedFeatures: ResolvedServerFeatureMap;
+        unSanitizedEditorConfig: ServerEditorConfig;
+    }) => Promise<ServerFeature<SanitizedProps, ClientProps>> | ServerFeature<SanitizedProps, ClientProps>) | Omit<ServerFeature<SanitizedProps, ClientProps>, 'sanitizedServerFeatureProps'>;
+};
+export declare const createServerFeature: <UnSanitizedProps = undefined, SanitizedProps = UnSanitizedProps, ClientProps = undefined>(args: CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps>) => FeatureProviderProviderServer<UnSanitizedProps, SanitizedProps, ClientProps>;
+//# sourceMappingURL=createServerFeature.d.ts.map

package/dist/utilities/createServerFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createServerFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACb,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,MAAM,MAAM,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,IAAI,IAAI,CACvF,qBAAqB,CAAC,gBAAgB,EAAE,WAAW,CAAC,EACpD,cAAc,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,KAAK,CACrE,GAAG;IACF,OAAO,EACH,CAAC,CAAC,KAAK,EAAE;QACP,MAAM,EAAE,eAAe,CAAA;QACvB,mDAAmD;QACnD,kBAAkB,EAAE,wBAAwB,CAAA;QAC5C,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,KAAK,EAAE,gBAAgB,CAAA;QAEvB,gBAAgB,EAAE,wBAAwB,CAAA;QAE1C,uBAAuB,EAAE,kBAAkB,CAAA;KAC5C,KACG,OAAO,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GACnD,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GAC/C,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;CACpF,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,CAChC,gBAAgB,GAAG,SAAS,EAC5B,cAAc,GAAG,gBAAgB,EACjC,WAAW,GAAG,SAAS,EAEvB,IAAI,EAAE,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CAAC,KACzE,6BAA6B,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CA8C/E,CAAA"}

package/dist/utilities/createServerFeature.js

@@ -0,0 +1,34 @@
+export const createServerFeature = ({ dependencies, dependenciesPriority, dependenciesSoft, feature, key })=>{
+    const featureProviderProviderServer = (props)=>{
+        const featureProviderServer = {
+            dependencies,
+            dependenciesPriority,
+            dependenciesSoft,
+            key,
+            serverFeatureProps: props
+        };
+        if (typeof feature === 'function') {
+            featureProviderServer.feature = async ({ config, featureProviderMap, isRoot, resolvedFeatures, unSanitizedEditorConfig })=>{
+                const toReturn = await feature({
+                    config,
+                    featureProviderMap,
+                    isRoot,
+                    props,
+                    resolvedFeatures,
+                    unSanitizedEditorConfig
+                });
+                if (toReturn.sanitizedServerFeatureProps === null) {
+                    toReturn.sanitizedServerFeatureProps = props;
+                }
+                return toReturn;
+            };
+        } else {
+            feature.sanitizedServerFeatureProps = props;
+            featureProviderServer.feature = feature;
+        }
+        return featureProviderServer;
+    };
+    return featureProviderProviderServer;
+};
+
+//# sourceMappingURL=createServerFeature.js.map

package/dist/utilities/createServerFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createServerFeature.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from '../features/typesServer.js'\nimport type { ServerEditorConfig } from '../lexical/config/types.js'\n\nexport type CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps> = Pick<\n  FeatureProviderServer<UnSanitizedProps, ClientProps>,\n  'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'\n> & {\n  feature:\n    | ((props: {\n        config: SanitizedConfig\n        /** unSanitizedEditorConfig.features, but mapped */\n        featureProviderMap: ServerFeatureProviderMap\n        isRoot?: boolean\n        props: UnSanitizedProps\n        // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n        resolvedFeatures: ResolvedServerFeatureMap\n        // unSanitized EditorConfig,\n        unSanitizedEditorConfig: ServerEditorConfig\n      }) =>\n        | Promise<ServerFeature<SanitizedProps, ClientProps>>\n        | ServerFeature<SanitizedProps, ClientProps>)\n    | Omit<ServerFeature<SanitizedProps, ClientProps>, 'sanitizedServerFeatureProps'>\n}\n\nexport const createServerFeature: <\n  UnSanitizedProps = undefined,\n  SanitizedProps = UnSanitizedProps,\n  ClientProps = undefined,\n>(\n  args: CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps>,\n) => FeatureProviderProviderServer<UnSanitizedProps, SanitizedProps, ClientProps> = ({\n  dependencies,\n  dependenciesPriority,\n  dependenciesSoft,\n  feature,\n  key,\n}) => {\n  const featureProviderProviderServer: FeatureProviderProviderServer<any, any, any> = (props) => {\n    const featureProviderServer: Partial<FeatureProviderServer<any, any, any>> = {\n      dependencies,\n      dependenciesPriority,\n      dependenciesSoft,\n      key,\n      serverFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderServer.feature = async ({\n        config,\n        featureProviderMap,\n        isRoot,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = await feature({\n          config,\n          featureProviderMap,\n          isRoot,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedServerFeatureProps === null) {\n          toReturn.sanitizedServerFeatureProps = props\n        }\n        return toReturn\n      }\n    } else {\n      ;(feature as ServerFeature<any, any>).sanitizedServerFeatureProps = props\n      featureProviderServer.feature = feature as ServerFeature<any, any>\n    }\n    return featureProviderServer as FeatureProviderServer<any, any, any>\n  }\n\n  return featureProviderProviderServer\n}\n"],"names":["createServerFeature","dependencies","dependenciesPriority","dependenciesSoft","feature","key","featureProviderProviderServer","props","featureProviderServer","serverFeatureProps","config","featureProviderMap","isRoot","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedServerFeatureProps"],"mappings":"AAgCA,OAAO,MAAMA,sBAMuE,CAAC,EACnFC,YAAY,EACZC,oBAAoB,EACpBC,gBAAgB,EAChBC,OAAO,EACPC,GAAG,EACJ;IACC,MAAMC,gCAA8E,CAACC;QACnF,MAAMC,wBAAuE;YAC3EP;YACAC;YACAC;YACAE;YACAI,oBAAoBF;QACtB;QAEA,IAAI,OAAOH,YAAY,YAAY;YACjCI,sBAAsBJ,OAAO,GAAG,OAAO,EACrCM,MAAM,EACNC,kBAAkB,EAClBC,MAAM,EACNC,gBAAgB,EAChBC,uBAAuB,EACxB;gBACC,MAAMC,WAAW,MAAMX,QAAQ;oBAC7BM;oBACAC;oBACAC;oBACAL;oBACAM;oBACAC;gBACF;gBAEA,IAAIC,SAASC,2BAA2B,KAAK,MAAM;oBACjDD,SAASC,2BAA2B,GAAGT;gBACzC;gBACA,OAAOQ;YACT;QACF,OAAO;YACHX,QAAoCY,2BAA2B,GAAGT;YACpEC,sBAAsBJ,OAAO,GAAGA;QAClC;QACA,OAAOI;IACT;IAEA,OAAOF;AACT,EAAC"}

package/dist/utilities/fieldsDrawer/Drawer.d.ts

@@ -0,0 +1,18 @@
+import type { FormState } from 'payload';
+import React from 'react';
+export type FieldsDrawerProps = {
+    className?: string;
+    data: any;
+    drawerSlug: string;
+    drawerTitle?: string;
+    featureKey: string;
+    handleDrawerSubmit: (fields: FormState, data: Record<string, unknown>) => void;
+    schemaPathSuffix?: string;
+};
+/**
+ * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.
+ * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only
+ * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.
+ */
+export declare const FieldsDrawer: React.FC<FieldsDrawerProps>;
+//# sourceMappingURL=Drawer.d.ts.map

package/dist/utilities/fieldsDrawer/Drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drawer.d.ts","sourceRoot":"","sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxC,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,GAAG,CAAA;IACT,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAqBpD,CAAA"}

package/dist/utilities/fieldsDrawer/Drawer.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Drawer } from '@payloadcms/ui';
+import React from 'react';
+import { DrawerContent } from './DrawerContent.js';
+/**
+ * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.
+ * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only
+ * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.
+ */ export const FieldsDrawer = ({ className, data, drawerSlug, drawerTitle, featureKey, handleDrawerSubmit, schemaPathSuffix })=>{
+    // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content
+    // to DrawerContent, this should be faster
+    return /*#__PURE__*/ _jsx(Drawer, {
+        className: className,
+        slug: drawerSlug,
+        title: drawerTitle ?? '',
+        children: /*#__PURE__*/ _jsx(DrawerContent, {
+            data: data,
+            featureKey: featureKey,
+            handleDrawerSubmit: handleDrawerSubmit,
+            schemaPathSuffix: schemaPathSuffix
+        })
+    });
+};
+
+//# sourceMappingURL=Drawer.js.map

package/dist/utilities/fieldsDrawer/Drawer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"sourcesContent":["'use client'\nimport type { FormState } from 'payload'\n\nimport { Drawer } from '@payloadcms/ui'\nimport React from 'react'\n\nimport { DrawerContent } from './DrawerContent.js'\n\nexport type FieldsDrawerProps = {\n  className?: string\n  data: any\n  drawerSlug: string\n  drawerTitle?: string\n  featureKey: string\n  handleDrawerSubmit: (fields: FormState, data: Record<string, unknown>) => void\n  schemaPathSuffix?: string\n}\n\n/**\n * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.\n * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only\n * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.\n */\nexport const FieldsDrawer: React.FC<FieldsDrawerProps> = ({\n  className,\n  data,\n  drawerSlug,\n  drawerTitle,\n  featureKey,\n  handleDrawerSubmit,\n  schemaPathSuffix,\n}) => {\n  // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content\n  // to DrawerContent, this should be faster\n  return (\n    <Drawer className={className} slug={drawerSlug} title={drawerTitle ?? ''}>\n      <DrawerContent\n        data={data}\n        featureKey={featureKey}\n        handleDrawerSubmit={handleDrawerSubmit}\n        schemaPathSuffix={schemaPathSuffix}\n      />\n    </Drawer>\n  )\n}\n"],"names":["Drawer","React","DrawerContent","FieldsDrawer","className","data","drawerSlug","drawerTitle","featureKey","handleDrawerSubmit","schemaPathSuffix","slug","title"],"mappings":"AAAA;;AAGA,SAASA,MAAM,QAAQ,iBAAgB;AACvC,OAAOC,WAAW,QAAO;AAEzB,SAASC,aAAa,QAAQ,qBAAoB;AAYlD;;;;CAIC,GACD,OAAO,MAAMC,eAA4C,CAAC,EACxDC,SAAS,EACTC,IAAI,EACJC,UAAU,EACVC,WAAW,EACXC,UAAU,EACVC,kBAAkB,EAClBC,gBAAgB,EACjB;IACC,uGAAuG;IACvG,0CAA0C;IAC1C,qBACE,KAACV;QAAOI,WAAWA;QAAWO,MAAML;QAAYM,OAAOL,eAAe;kBACpE,cAAA,KAACL;YACCG,MAAMA;YACNG,YAAYA;YACZC,oBAAoBA;YACpBC,kBAAkBA;;;AAI1B,EAAC"}

package/dist/utilities/fieldsDrawer/DrawerContent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { FieldsDrawerProps } from './Drawer.js';
+export declare const DrawerContent: React.FC<Omit<FieldsDrawerProps, 'drawerSlug' | 'drawerTitle'>>;
+//# sourceMappingURL=DrawerContent.d.ts.map

package/dist/utilities/fieldsDrawer/DrawerContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawerContent.d.ts","sourceRoot":"","sources":["../../../src/utilities/fieldsDrawer/DrawerContent.tsx"],"names":[],"mappings":"AAcA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAG/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAIpD,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,YAAY,GAAG,aAAa,CAAC,CAmFzF,CAAA"}

package/dist/utilities/fieldsDrawer/DrawerContent.js

@@ -0,0 +1,92 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Form, FormSubmit, RenderFields, useConfig, useDocumentInfo, useFieldProps, useTranslation } from '@payloadcms/ui';
+import { getFormState } from '@payloadcms/ui/shared';
+import React, { useCallback, useEffect, useState } from 'react';
+import { v4 as uuid } from 'uuid';
+import { useEditorConfigContext } from '../../lexical/config/client/EditorConfigProvider.js';
+export const DrawerContent = ({ data, featureKey, handleDrawerSubmit, schemaPathSuffix })=>{
+    const { t } = useTranslation();
+    const { id } = useDocumentInfo();
+    const { schemaPath } = useFieldProps();
+    const config = useConfig();
+    const [initialState, setInitialState] = useState(false);
+    const { field: { richTextComponentMap } } = useEditorConfigContext();
+    const componentMapRenderedFieldsPath = `lexical_internal_feature.${featureKey}.fields${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`;
+    const schemaFieldsPath = `${schemaPath}.lexical_internal_feature.${featureKey}${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`;
+    const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema
+    ;
+    useEffect(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await getFormState({
+                apiRoute: config.routes.api,
+                body: {
+                    id,
+                    data,
+                    operation: 'update',
+                    schemaPath: schemaFieldsPath
+                },
+                serverURL: config.serverURL
+            }) // Form State
+            ;
+            setInitialState(state);
+        };
+        if (data) {
+            void awaitInitialState();
+        }
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id,
+        data
+    ]);
+    const onChange = useCallback(async ({ formState: prevFormState })=>{
+        return await getFormState({
+            apiRoute: config.routes.api,
+            body: {
+                id,
+                formState: prevFormState,
+                operation: 'update',
+                schemaPath: schemaFieldsPath
+            },
+            serverURL: config.serverURL
+        });
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id
+    ]);
+    if (initialState === false) {
+        return null;
+    }
+    return /*#__PURE__*/ _jsxs(Form, {
+        beforeSubmit: [
+            onChange
+        ],
+        disableValidationOnSubmit: true,
+        fields: Array.isArray(fieldMap) ? fieldMap : [],
+        initialState: initialState,
+        onChange: [
+            onChange
+        ],
+        onSubmit: handleDrawerSubmit,
+        uuid: uuid(),
+        children: [
+            /*#__PURE__*/ _jsx(RenderFields, {
+                fieldMap: Array.isArray(fieldMap) ? fieldMap : [],
+                forceRender: true,
+                path: "" // See Blocks feature path for details as for why this is empty
+                ,
+                readOnly: false,
+                schemaPath: schemaFieldsPath
+            }),
+            /*#__PURE__*/ _jsx(FormSubmit, {
+                children: t('fields:saveChanges')
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=DrawerContent.js.map

package/dist/utilities/fieldsDrawer/DrawerContent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/fieldsDrawer/DrawerContent.tsx"],"sourcesContent":["'use client'\nimport type { FormProps } from '@payloadcms/ui'\nimport type { FormState } from 'payload'\n\nimport {\n  Form,\n  FormSubmit,\n  RenderFields,\n  useConfig,\n  useDocumentInfo,\n  useFieldProps,\n  useTranslation,\n} from '@payloadcms/ui'\nimport { getFormState } from '@payloadcms/ui/shared'\nimport React, { useCallback, useEffect, useState } from 'react'\nimport { v4 as uuid } from 'uuid'\n\nimport type { FieldsDrawerProps } from './Drawer.js'\n\nimport { useEditorConfigContext } from '../../lexical/config/client/EditorConfigProvider.js'\n\nexport const DrawerContent: React.FC<Omit<FieldsDrawerProps, 'drawerSlug' | 'drawerTitle'>> = ({\n  data,\n  featureKey,\n  handleDrawerSubmit,\n  schemaPathSuffix,\n}) => {\n  const { t } = useTranslation()\n  const { id } = useDocumentInfo()\n  const { schemaPath } = useFieldProps()\n  const config = useConfig()\n  const [initialState, setInitialState] = useState<FormState | false>(false)\n  const {\n    field: { richTextComponentMap },\n  } = useEditorConfigContext()\n\n  const componentMapRenderedFieldsPath = `lexical_internal_feature.${featureKey}.fields${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`\n  const schemaFieldsPath = `${schemaPath}.lexical_internal_feature.${featureKey}${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`\n\n  const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema\n\n  useEffect(() => {\n    const awaitInitialState = async () => {\n      const state = await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          data,\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      }) // Form State\n\n      setInitialState(state)\n    }\n\n    if (data) {\n      void awaitInitialState()\n    }\n  }, [config.routes.api, config.serverURL, schemaFieldsPath, id, data])\n\n  const onChange: FormProps['onChange'][0] = useCallback(\n    async ({ formState: prevFormState }) => {\n      return await getFormState({\n        apiRoute: config.routes.api,\n        body: {\n          id,\n          formState: prevFormState,\n          operation: 'update',\n          schemaPath: schemaFieldsPath,\n        },\n        serverURL: config.serverURL,\n      })\n    },\n\n    [config.routes.api, config.serverURL, schemaFieldsPath, id],\n  )\n\n  if (initialState === false) {\n    return null\n  }\n\n  return (\n    <Form\n      beforeSubmit={[onChange]}\n      disableValidationOnSubmit\n      fields={Array.isArray(fieldMap) ? fieldMap : []}\n      initialState={initialState}\n      onChange={[onChange]}\n      onSubmit={handleDrawerSubmit}\n      uuid={uuid()}\n    >\n      <RenderFields\n        fieldMap={Array.isArray(fieldMap) ? fieldMap : []}\n        forceRender\n        path=\"\" // See Blocks feature path for details as for why this is empty\n        readOnly={false}\n        schemaPath={schemaFieldsPath}\n      />\n\n      <FormSubmit>{t('fields:saveChanges')}</FormSubmit>\n    </Form>\n  )\n}\n"],"names":["Form","FormSubmit","RenderFields","useConfig","useDocumentInfo","useFieldProps","useTranslation","getFormState","React","useCallback","useEffect","useState","v4","uuid","useEditorConfigContext","DrawerContent","data","featureKey","handleDrawerSubmit","schemaPathSuffix","t","id","schemaPath","config","initialState","setInitialState","field","richTextComponentMap","componentMapRenderedFieldsPath","schemaFieldsPath","fieldMap","get","awaitInitialState","state","apiRoute","routes","api","body","operation","serverURL","onChange","formState","prevFormState","beforeSubmit","disableValidationOnSubmit","fields","Array","isArray","onSubmit","forceRender","path","readOnly"],"mappings":"AAAA;;AAIA,SACEA,IAAI,EACJC,UAAU,EACVC,YAAY,EACZC,SAAS,EACTC,eAAe,EACfC,aAAa,EACbC,cAAc,QACT,iBAAgB;AACvB,SAASC,YAAY,QAAQ,wBAAuB;AACpD,OAAOC,SAASC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAC/D,SAASC,MAAMC,IAAI,QAAQ,OAAM;AAIjC,SAASC,sBAAsB,QAAQ,sDAAqD;AAE5F,OAAO,MAAMC,gBAAiF,CAAC,EAC7FC,IAAI,EACJC,UAAU,EACVC,kBAAkB,EAClBC,gBAAgB,EACjB;IACC,MAAM,EAAEC,CAAC,EAAE,GAAGd;IACd,MAAM,EAAEe,EAAE,EAAE,GAAGjB;IACf,MAAM,EAAEkB,UAAU,EAAE,GAAGjB;IACvB,MAAMkB,SAASpB;IACf,MAAM,CAACqB,cAAcC,gBAAgB,GAAGd,SAA4B;IACpE,MAAM,EACJe,OAAO,EAAEC,oBAAoB,EAAE,EAChC,GAAGb;IAEJ,MAAMc,iCAAiC,CAAC,yBAAyB,EAAEX,WAAW,OAAO,EAAEE,mBAAmB,CAAC,CAAC,EAAEA,iBAAiB,CAAC,GAAG,GAAG,CAAC;IACvI,MAAMU,mBAAmB,CAAC,EAAEP,WAAW,0BAA0B,EAAEL,WAAW,EAAEE,mBAAmB,CAAC,CAAC,EAAEA,iBAAiB,CAAC,GAAG,GAAG,CAAC;IAEhI,MAAMW,WAAWH,qBAAqBI,GAAG,CAACH,gCAAgC,eAAe;;IAEzFlB,UAAU;QACR,MAAMsB,oBAAoB;YACxB,MAAMC,QAAQ,MAAM1B,aAAa;gBAC/B2B,UAAUX,OAAOY,MAAM,CAACC,GAAG;gBAC3BC,MAAM;oBACJhB;oBACAL;oBACAsB,WAAW;oBACXhB,YAAYO;gBACd;gBACAU,WAAWhB,OAAOgB,SAAS;YAC7B,GAAG,aAAa;;YAEhBd,gBAAgBQ;QAClB;QAEA,IAAIjB,MAAM;YACR,KAAKgB;QACP;IACF,GAAG;QAACT,OAAOY,MAAM,CAACC,GAAG;QAAEb,OAAOgB,SAAS;QAAEV;QAAkBR;QAAIL;KAAK;IAEpE,MAAMwB,WAAqC/B,YACzC,OAAO,EAAEgC,WAAWC,aAAa,EAAE;QACjC,OAAO,MAAMnC,aAAa;YACxB2B,UAAUX,OAAOY,MAAM,CAACC,GAAG;YAC3BC,MAAM;gBACJhB;gBACAoB,WAAWC;gBACXJ,WAAW;gBACXhB,YAAYO;YACd;YACAU,WAAWhB,OAAOgB,SAAS;QAC7B;IACF,GAEA;QAAChB,OAAOY,MAAM,CAACC,GAAG;QAAEb,OAAOgB,SAAS;QAAEV;QAAkBR;KAAG;IAG7D,IAAIG,iBAAiB,OAAO;QAC1B,OAAO;IACT;IAEA,qBACE,MAACxB;QACC2C,cAAc;YAACH;SAAS;QACxBI,yBAAyB;QACzBC,QAAQC,MAAMC,OAAO,CAACjB,YAAYA,WAAW,EAAE;QAC/CN,cAAcA;QACdgB,UAAU;YAACA;SAAS;QACpBQ,UAAU9B;QACVL,MAAMA;;0BAEN,KAACX;gBACC4B,UAAUgB,MAAMC,OAAO,CAACjB,YAAYA,WAAW,EAAE;gBACjDmB,WAAW;gBACXC,MAAK,GAAG,+DAA+D;;gBACvEC,UAAU;gBACV7B,YAAYO;;0BAGd,KAAC5B;0BAAYmB,EAAE;;;;AAGrB,EAAC"}

package/dist/utilities/forEachNodeRecursively.d.ts

@@ -0,0 +1,10 @@
+import type { SerializedLexicalNode } from 'lexical';
+export declare function recurseNodes({ callback, nodes, }: {
+    callback: (node: SerializedLexicalNode) => void;
+    nodes: SerializedLexicalNode[];
+}): void;
+export declare function recurseNodesAsync({ callback, nodes, }: {
+    callback: (node: SerializedLexicalNode) => Promise<void>;
+    nodes: SerializedLexicalNode[];
+}): Promise<void>;
+//# sourceMappingURL=forEachNodeRecursively.d.ts.map

package/dist/utilities/forEachNodeRecursively.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forEachNodeRecursively.d.ts","sourceRoot":"","sources":["../../src/utilities/forEachNodeRecursively.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAA;IAC/C,KAAK,EAAE,qBAAqB,EAAE,CAAA;CAC/B,QAQA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACxD,KAAK,EAAE,qBAAqB,EAAE,CAAA;CAC/B,iBAQA"}

package/dist/utilities/forEachNodeRecursively.js

@@ -0,0 +1,24 @@
+export function recurseNodes({ callback, nodes }) {
+    for (const node of nodes){
+        callback(node);
+        if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {
+            recurseNodes({
+                callback,
+                nodes: node.children
+            });
+        }
+    }
+}
+export async function recurseNodesAsync({ callback, nodes }) {
+    for (const node of nodes){
+        await callback(node);
+        if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {
+            await recurseNodesAsync({
+                callback,
+                nodes: node.children
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=forEachNodeRecursively.js.map

package/dist/utilities/forEachNodeRecursively.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/forEachNodeRecursively.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport function recurseNodes({\n  callback,\n  nodes,\n}: {\n  callback: (node: SerializedLexicalNode) => void\n  nodes: SerializedLexicalNode[]\n}) {\n  for (const node of nodes) {\n    callback(node)\n\n    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {\n      recurseNodes({ callback, nodes: node.children as SerializedLexicalNode[] })\n    }\n  }\n}\n\nexport async function recurseNodesAsync({\n  callback,\n  nodes,\n}: {\n  callback: (node: SerializedLexicalNode) => Promise<void>\n  nodes: SerializedLexicalNode[]\n}) {\n  for (const node of nodes) {\n    await callback(node)\n\n    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {\n      await recurseNodesAsync({ callback, nodes: node.children as SerializedLexicalNode[] })\n    }\n  }\n}\n"],"names":["recurseNodes","callback","nodes","node","Array","isArray","children","length","recurseNodesAsync"],"mappings":"AAEA,OAAO,SAASA,aAAa,EAC3BC,QAAQ,EACRC,KAAK,EAIN;IACC,KAAK,MAAMC,QAAQD,MAAO;QACxBD,SAASE;QAET,IAAI,cAAcA,QAAQC,MAAMC,OAAO,CAACF,MAAMG,aAAaH,MAAMG,UAAUC,QAAQ;YACjFP,aAAa;gBAAEC;gBAAUC,OAAOC,KAAKG,QAAQ;YAA4B;QAC3E;IACF;AACF;AAEA,OAAO,eAAeE,kBAAkB,EACtCP,QAAQ,EACRC,KAAK,EAIN;IACC,KAAK,MAAMC,QAAQD,MAAO;QACxB,MAAMD,SAASE;QAEf,IAAI,cAAcA,QAAQC,MAAMC,OAAO,CAACF,MAAMG,aAAaH,MAAMG,UAAUC,QAAQ;YACjF,MAAMC,kBAAkB;gBAAEP;gBAAUC,OAAOC,KAAKG,QAAQ;YAA4B;QACtF;IACF;AACF"}

package/dist/utilities/generateComponentMap.d.ts

@@ -0,0 +1,6 @@
+import type { RichTextAdapter } from 'payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+export declare const getGenerateComponentMap: (args: {
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+}) => RichTextAdapter["generateComponentMap"];
+//# sourceMappingURL=generateComponentMap.d.ts.map

package/dist/utilities/generateComponentMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateComponentMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateComponentMap.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAK9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAG1E,eAAO,MAAM,uBAAuB,SAC3B;IACL,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,KAAG,eAAe,CAAC,sBAAsB,CA8GzC,CAAA"}

package/dist/utilities/generateComponentMap.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+import { mapFields } from '@payloadcms/ui/utilities/buildComponentMap';
+import React from 'react';
+export const getGenerateComponentMap = (args)=>({ WithServerSideProps, config, i18n, schemaPath })=>{
+        const componentMap = new Map();
+        // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
+        const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort((a, b)=>a[1].order - b[1].order);
+        componentMap.set(`features`, resolvedFeatureMapArray.map(([featureKey, resolvedFeature])=>{
+            const ClientComponent = resolvedFeature.ClientFeature;
+            const clientComponentProps = resolvedFeature.clientFeatureProps;
+            /**
+           * Handle Feature Component Maps
+           */ if ('generateComponentMap' in resolvedFeature && typeof resolvedFeature.generateComponentMap === 'function') {
+                const components = resolvedFeature.generateComponentMap({
+                    config,
+                    i18n,
+                    props: resolvedFeature.sanitizedServerFeatureProps,
+                    schemaPath
+                });
+                for(const componentKey in components){
+                    const Component = components[componentKey];
+                    if (Component) {
+                        componentMap.set(`lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`, /*#__PURE__*/ _jsx(WithServerSideProps, {
+                            Component: Component,
+                            componentKey: componentKey,
+                            featureKey: resolvedFeature.key
+                        }, `${resolvedFeature.key}-${componentKey}`));
+                    }
+                }
+            }
+            /**
+           * Handle Feature Schema Maps (rendered fields)
+           */ if ('generateSchemaMap' in resolvedFeature && typeof resolvedFeature.generateSchemaMap === 'function') {
+                const schemas = resolvedFeature.generateSchemaMap({
+                    config,
+                    i18n,
+                    props: resolvedFeature.sanitizedServerFeatureProps,
+                    schemaMap: new Map(),
+                    schemaPath
+                });
+                if (schemas) {
+                    for (const [schemaKey, fields] of schemas.entries()){
+                        const mappedFields = mapFields({
+                            WithServerSideProps,
+                            config,
+                            disableAddingID: true,
+                            fieldSchema: fields,
+                            i18n,
+                            parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,
+                            readOnly: false
+                        });
+                        componentMap.set(`lexical_internal_feature.${featureKey}.fields.${schemaKey}`, mappedFields);
+                    }
+                }
+            }
+            if (!ClientComponent) {
+                return null;
+            }
+            return {
+                ClientFeature: clientComponentProps && typeof clientComponentProps === 'object' ? /*#__PURE__*/ _createElement(ClientComponent, {
+                    ...clientComponentProps,
+                    featureKey: resolvedFeature.key,
+                    key: resolvedFeature.key,
+                    order: resolvedFeature.order
+                }) : /*#__PURE__*/ _jsx(ClientComponent, {
+                    featureKey: resolvedFeature.key,
+                    order: resolvedFeature.order
+                }, resolvedFeature.key),
+                key: resolvedFeature.key,
+                order: resolvedFeature.order
+            };
+        }).filter((feature)=>feature !== null));
+        return componentMap;
+    };
+
+//# sourceMappingURL=generateComponentMap.js.map

package/dist/utilities/generateComponentMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/generateComponentMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { mapFields } from '@payloadcms/ui/utilities/buildComponentMap'\nimport React from 'react'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { GeneratedFeatureProviderComponent } from '../types.js'\n\nexport const getGenerateComponentMap =\n  (args: {\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateComponentMap'] =>\n  ({ WithServerSideProps, config, i18n, schemaPath }) => {\n    const componentMap = new Map()\n\n    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n    const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort(\n      (a, b) => a[1].order - b[1].order,\n    )\n\n    componentMap.set(\n      `features`,\n      resolvedFeatureMapArray\n        .map(([featureKey, resolvedFeature]) => {\n          const ClientComponent = resolvedFeature.ClientFeature\n          const clientComponentProps = resolvedFeature.clientFeatureProps\n\n          /**\n           * Handle Feature Component Maps\n           */\n          if (\n            'generateComponentMap' in resolvedFeature &&\n            typeof resolvedFeature.generateComponentMap === 'function'\n          ) {\n            const components = resolvedFeature.generateComponentMap({\n              config,\n              i18n,\n              props: resolvedFeature.sanitizedServerFeatureProps,\n              schemaPath,\n            })\n\n            for (const componentKey in components) {\n              const Component = components[componentKey]\n\n              if (Component) {\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`,\n                  <WithServerSideProps\n                    Component={Component}\n                    componentKey={componentKey}\n                    featureKey={resolvedFeature.key}\n                    key={`${resolvedFeature.key}-${componentKey}`}\n                  />,\n                )\n              }\n            }\n          }\n\n          /**\n           * Handle Feature Schema Maps (rendered fields)\n           */\n          if (\n            'generateSchemaMap' in resolvedFeature &&\n            typeof resolvedFeature.generateSchemaMap === 'function'\n          ) {\n            const schemas = resolvedFeature.generateSchemaMap({\n              config,\n              i18n,\n              props: resolvedFeature.sanitizedServerFeatureProps,\n              schemaMap: new Map(),\n              schemaPath,\n            })\n\n            if (schemas) {\n              for (const [schemaKey, fields] of schemas.entries()) {\n                const mappedFields = mapFields({\n                  WithServerSideProps,\n                  config,\n                  disableAddingID: true,\n                  fieldSchema: fields,\n                  i18n,\n                  parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  readOnly: false,\n                })\n\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  mappedFields,\n                )\n              }\n            }\n          }\n\n          if (!ClientComponent) {\n            return null\n          }\n\n          return {\n            ClientFeature:\n              clientComponentProps && typeof clientComponentProps === 'object' ? (\n                <ClientComponent\n                  {...clientComponentProps}\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ) : (\n                <ClientComponent\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ),\n            key: resolvedFeature.key,\n            order: resolvedFeature.order,\n          } as GeneratedFeatureProviderComponent\n        })\n        .filter((feature) => feature !== null),\n    )\n\n    return componentMap\n  }\n"],"names":["mapFields","React","getGenerateComponentMap","args","WithServerSideProps","config","i18n","schemaPath","componentMap","Map","resolvedFeatureMapArray","Array","from","resolvedFeatureMap","entries","sort","a","b","order","set","map","featureKey","resolvedFeature","ClientComponent","ClientFeature","clientComponentProps","clientFeatureProps","generateComponentMap","components","props","sanitizedServerFeatureProps","componentKey","Component","key","generateSchemaMap","schemas","schemaMap","schemaKey","fields","mappedFields","disableAddingID","fieldSchema","parentPath","readOnly","filter","feature"],"mappings":";;AAEA,SAASA,SAAS,QAAQ,6CAA4C;AACtE,OAAOC,WAAW,QAAO;AAKzB,OAAO,MAAMC,0BACX,CAACC,OAGD,CAAC,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,IAAI,EAAEC,UAAU,EAAE;QAChD,MAAMC,eAAe,IAAIC;QAEzB,gHAAgH;QAChH,MAAMC,0BAA0BC,MAAMC,IAAI,CAACT,KAAKU,kBAAkB,CAACC,OAAO,IAAIC,IAAI,CAChF,CAACC,GAAGC,IAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;QAGnCV,aAAaW,GAAG,CACd,CAAC,QAAQ,CAAC,EACVT,wBACGU,GAAG,CAAC,CAAC,CAACC,YAAYC,gBAAgB;YACjC,MAAMC,kBAAkBD,gBAAgBE,aAAa;YACrD,MAAMC,uBAAuBH,gBAAgBI,kBAAkB;YAE/D;;WAEC,GACD,IACE,0BAA0BJ,mBAC1B,OAAOA,gBAAgBK,oBAAoB,KAAK,YAChD;gBACA,MAAMC,aAAaN,gBAAgBK,oBAAoB,CAAC;oBACtDtB;oBACAC;oBACAuB,OAAOP,gBAAgBQ,2BAA2B;oBAClDvB;gBACF;gBAEA,IAAK,MAAMwB,gBAAgBH,WAAY;oBACrC,MAAMI,YAAYJ,UAAU,CAACG,aAAa;oBAE1C,IAAIC,WAAW;wBACbxB,aAAaW,GAAG,CACd,CAAC,yBAAyB,EAAEE,WAAW,6BAA6B,EAAEU,aAAa,CAAC,gBACpF,KAAC3B;4BACC4B,WAAWA;4BACXD,cAAcA;4BACdV,YAAYC,gBAAgBW,GAAG;2BAC1B,CAAC,EAAEX,gBAAgBW,GAAG,CAAC,CAAC,EAAEF,aAAa,CAAC;oBAGnD;gBACF;YACF;YAEA;;WAEC,GACD,IACE,uBAAuBT,mBACvB,OAAOA,gBAAgBY,iBAAiB,KAAK,YAC7C;gBACA,MAAMC,UAAUb,gBAAgBY,iBAAiB,CAAC;oBAChD7B;oBACAC;oBACAuB,OAAOP,gBAAgBQ,2BAA2B;oBAClDM,WAAW,IAAI3B;oBACfF;gBACF;gBAEA,IAAI4B,SAAS;oBACX,KAAK,MAAM,CAACE,WAAWC,OAAO,IAAIH,QAAQrB,OAAO,GAAI;wBACnD,MAAMyB,eAAevC,UAAU;4BAC7BI;4BACAC;4BACAmC,iBAAiB;4BACjBC,aAAaH;4BACbhC;4BACAoC,YAAY,CAAC,EAAEnC,WAAW,0BAA0B,EAAEc,WAAW,QAAQ,EAAEgB,UAAU,CAAC;4BACtFM,UAAU;wBACZ;wBAEAnC,aAAaW,GAAG,CACd,CAAC,yBAAyB,EAAEE,WAAW,QAAQ,EAAEgB,UAAU,CAAC,EAC5DE;oBAEJ;gBACF;YACF;YAEA,IAAI,CAAChB,iBAAiB;gBACpB,OAAO;YACT;YAEA,OAAO;gBACLC,eACEC,wBAAwB,OAAOA,yBAAyB,yBACtD,eAACF;oBACE,GAAGE,oBAAoB;oBACxBJ,YAAYC,gBAAgBW,GAAG;oBAC/BA,KAAKX,gBAAgBW,GAAG;oBACxBf,OAAOI,gBAAgBJ,KAAK;mCAG9B,KAACK;oBACCF,YAAYC,gBAAgBW,GAAG;oBAE/Bf,OAAOI,gBAAgBJ,KAAK;mBADvBI,gBAAgBW,GAAG;gBAI9BA,KAAKX,gBAAgBW,GAAG;gBACxBf,OAAOI,gBAAgBJ,KAAK;YAC9B;QACF,GACC0B,MAAM,CAAC,CAACC,UAAYA,YAAY;QAGrC,OAAOrC;IACT,EAAC"}

package/dist/utilities/generateSchemaMap.d.ts

@@ -0,0 +1,6 @@
+import type { RichTextAdapter } from 'payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+export declare const getGenerateSchemaMap: (args: {
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+}) => RichTextAdapter["generateSchemaMap"];
+//# sourceMappingURL=generateSchemaMap.d.ts.map

package/dist/utilities/generateSchemaMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAkC5F,CAAA"}

package/dist/utilities/generateSchemaMap.js

@@ -0,0 +1,31 @@
+import { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields';
+export const getGenerateSchemaMap = (args)=>({ config, i18n, schemaMap, schemaPath })=>{
+        for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()){
+            if (!('generateSchemaMap' in resolvedFeature) || typeof resolvedFeature.generateSchemaMap !== 'function') {
+                continue;
+            }
+            const schemas = resolvedFeature.generateSchemaMap({
+                config,
+                i18n,
+                props: resolvedFeature.sanitizedServerFeatureProps,
+                schemaMap,
+                schemaPath
+            });
+            if (schemas) {
+                for (const [schemaKey, fields] of schemas.entries()){
+                    // generate schema map entries for sub-fields using traverseFields
+                    traverseFields({
+                        config,
+                        fields,
+                        i18n,
+                        schemaMap: schemas,
+                        schemaPath: schemaKey
+                    });
+                    schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields);
+                }
+            }
+        }
+        return schemaMap;
+    };
+
+//# sourceMappingURL=generateSchemaMap.js.map

package/dist/utilities/generateSchemaMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, i18n, schemaMap, schemaPath }) => {\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        i18n,\n        props: resolvedFeature.sanitizedServerFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, fields] of schemas.entries()) {\n          // generate schema map entries for sub-fields using traverseFields\n          traverseFields({\n            config,\n            fields,\n            i18n,\n            schemaMap: schemas,\n            schemaPath: schemaKey,\n          })\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["traverseFields","getGenerateSchemaMap","args","config","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","set"],"mappings":"AAEA,SAASA,cAAc,QAAQ,8DAA6D;AAI5F,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QACtC,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIN,KAAKO,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDR;gBACAC;gBACAS,OAAOL,gBAAgBM,2BAA2B;gBAClDT;gBACAC;YACF;YAEA,IAAIM,SAAS;gBACX,KAAK,MAAM,CAACG,WAAWC,OAAO,IAAIJ,QAAQF,OAAO,GAAI;oBACnD,kEAAkE;oBAClEV,eAAe;wBACbG;wBACAa;wBACAZ;wBACAC,WAAWO;wBACXN,YAAYS;oBACd;oBAEAV,UAAUY,GAAG,CAAC,CAAC,EAAEX,WAAW,0BAA0B,EAAEC,WAAW,CAAC,EAAEQ,UAAU,CAAC,EAAEC;gBACrF;YACF;QACF;QAEA,OAAOX;IACT,EAAC"}

package/dist/utilities/migrateSlateToLexical/index.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+/**
+ * This goes through every single collection and field in the payload config, and migrates its data from Slate to Lexical. This does not support sub-fields within slate.
+ *
+ * It will only translate fields fulfilling all these requirements:
+ * - field schema uses lexical editor
+ * - lexical editor has SlateToLexicalFeature added
+ * - saved field data is in Slate format
+ *
+ * @param payload
+ */
+export declare function migrateSlateToLexical({ payload }: {
+    payload: Payload;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/utilities/migrateSlateToLexical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utilities/migrateSlateToLexical/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyC,OAAO,EAAE,MAAM,SAAS,CAAA;AAI7E;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,iBA0B5E"}