@ruya.sa/richtext-lexical 3.71.7

package/dist/utilities/buildEditorState.js

@@ -0,0 +1,85 @@
+/**
+ * Helper to build lexical editor state JSON from text and/or nodes.
+ *
+ * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.
+ * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.
+ * @returns The constructed editor state JSON.
+ *
+ * @example
+ *
+ * just passing text:
+ *
+ * ```ts
+ * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState
+ * ```
+ *
+ * @example
+ *
+ * passing nodes:
+ *
+ * ```ts
+ * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)
+ * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes
+ *   nodes: [
+ *     {
+ *       type: 'block',
+ *        fields: {
+ *          id: 'id',
+ *          blockName: 'Cool block',
+ *          blockType: 'myBlock',
+ *        },
+ *        format: 'left',
+ *        version: 1,
+ *      }
+ *   ],
+ * })
+ * ```
+ */export function buildEditorState({
+  nodes,
+  text
+}) {
+  const editorJSON = {
+    root: {
+      type: 'root',
+      children: [],
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+  if (text) {
+    editorJSON.root.children.push({
+      type: 'paragraph',
+      children: [{
+        type: 'text',
+        detail: 0,
+        format: 0,
+        mode: 'normal',
+        style: '',
+        text,
+        version: 1
+      }],
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      textFormat: 0,
+      textStyle: '',
+      version: 1
+    });
+  }
+  if (nodes?.length) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    editorJSON.root.children.push(...nodes);
+  }
+  return editorJSON;
+}
+/**
+ *
+ * Alias for `buildEditorState<DefaultNodeTypes>`
+ *
+ * @experimental this API may change or be removed in a minor release
+ * @internal
+ */
+export const buildDefaultEditorState = buildEditorState;
+//# sourceMappingURL=buildEditorState.js.map

package/dist/utilities/buildEditorState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildEditorState.js","names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length","buildDefaultEditorState"],"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { DefaultNodeTypes, DefaultTypedEditorState, TypedEditorState } from '../nodeTypes.js'\n\n/**\n * Helper to build lexical editor state JSON from text and/or nodes.\n *\n * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.\n * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.\n * @returns The constructed editor state JSON.\n *\n * @example\n *\n * just passing text:\n *\n * ```ts\n * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState\n * ```\n *\n * @example\n *\n * passing nodes:\n *\n * ```ts\n * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)\n * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes\n *   nodes: [\n *     {\n *       type: 'block',\n *        fields: {\n *          id: 'id',\n *          blockName: 'Cool block',\n *          blockType: 'myBlock',\n *        },\n *        format: 'left',\n *        version: 1,\n *      }\n *   ],\n * })\n * ```\n */\nexport function buildEditorState<T extends SerializedLexicalNode>({\n  nodes,\n  text,\n}: {\n  nodes?: TypedEditorState<T>['root']['children']\n  text?: string\n}): TypedEditorState<T> {\n  const editorJSON: DefaultTypedEditorState = {\n    root: {\n      type: 'root',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n\n  if (text) {\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [\n        {\n          type: 'text',\n          detail: 0,\n          format: 0,\n          mode: 'normal',\n          style: '',\n          text,\n          version: 1,\n        },\n      ],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  if (nodes?.length) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  return editorJSON as TypedEditorState<T>\n}\n\n/**\n *\n * Alias for `buildEditorState<DefaultNodeTypes>`\n *\n * @experimental this API may change or be removed in a minor release\n * @internal\n */\nexport const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes> =\n  buildEditorState<DefaultNodeTypes>\n"],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCA,OAAO,SAASA,iBAAkD;EAChEC,KAAK;EACLC;AAAI,CAIL;EACC,MAAMC,UAAA,GAAsC;IAC1CC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EAEA,IAAIR,IAAA,EAAM;IACRC,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,CACR;QACED,IAAA,EAAM;QACNO,MAAA,EAAQ;QACRJ,MAAA,EAAQ;QACRK,IAAA,EAAM;QACNC,KAAA,EAAO;QACPZ,IAAA;QACAQ,OAAA,EAAS;MACX,EACD;MACDH,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,IAAIT,KAAA,EAAOgB,MAAA,EAAQ;IACjB;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV,KAAA;EACpC;EAEA,OAAOE,UAAA;AACT;AAEA;;;;;;;AAOA,OAAO,MAAMe,uBAAA,GACXlB,gBAAA","ignoreList":[]}

package/dist/utilities/buildInitialState.d.ts

@@ -0,0 +1,30 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { ClientFieldSchemaMap, DocumentPreferences, FieldSchemaMap, FormState, Operation, PayloadRequest, RichTextField, SanitizedFieldPermissions } from '@ruya.sa/payload';
+export type InitialLexicalFormState = {
+    [nodeID: string]: {
+        [key: string]: any;
+        formState?: FormState;
+    };
+};
+type Props = {
+    context: {
+        clientFieldSchemaMap: ClientFieldSchemaMap;
+        collectionSlug: string;
+        disabled?: boolean;
+        documentData?: any;
+        field: RichTextField;
+        fieldSchemaMap: FieldSchemaMap;
+        id?: number | string;
+        lexicalFieldSchemaPath: string;
+        operation: Operation;
+        permissions?: SanitizedFieldPermissions;
+        preferences: DocumentPreferences;
+        renderFieldFn: any;
+        req: PayloadRequest;
+    };
+    initialState?: InitialLexicalFormState;
+    nodeData: SerializedLexicalNode[];
+};
+export declare function buildInitialState({ context, initialState: initialStateFromArgs, nodeData, }: Props): Promise<InitialLexicalFormState>;
+export {};
+//# sourceMappingURL=buildInitialState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildInitialState.d.ts","sourceRoot":"","sources":["../../src/utilities/buildInitialState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,SAAS,EACT,cAAc,EACd,aAAa,EACb,yBAAyB,EAC1B,MAAM,kBAAkB,CAAA;AAMzB,MAAM,MAAM,uBAAuB,GAAG;IACpC,CAAC,MAAM,EAAE,MAAM,GAAG;QAChB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;QAClB,SAAS,CAAC,EAAE,SAAS,CAAA;KACtB,CAAA;CACF,CAAA;AAED,KAAK,KAAK,GAAG;IACX,OAAO,EAAE;QACP,oBAAoB,EAAE,oBAAoB,CAAA;QAC1C,cAAc,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB,YAAY,CAAC,EAAE,GAAG,CAAA;QAClB,KAAK,EAAE,aAAa,CAAA;QACpB,cAAc,EAAE,cAAc,CAAA;QAC9B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;QACpB,sBAAsB,EAAE,MAAM,CAAA;QAC9B,SAAS,EAAE,SAAS,CAAA;QACpB,WAAW,CAAC,EAAE,yBAAyB,CAAA;QACvC,WAAW,EAAE,mBAAmB,CAAA;QAChC,aAAa,EAAE,GAAG,CAAA;QAClB,GAAG,EAAE,cAAc,CAAA;KACpB,CAAA;IACD,YAAY,CAAC,EAAE,uBAAuB,CAAA;IACtC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;CAClC,CAAA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,YAAY,EAAE,oBAAoB,EAClC,QAAQ,GACT,EAAE,KAAK,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA4D1C"}

package/dist/utilities/buildInitialState.js

@@ -0,0 +1,57 @@
+import { fieldSchemasToFormState } from '@ruya.sa/ui/forms/fieldSchemasToFormState';
+export async function buildInitialState({
+  context,
+  initialState: initialStateFromArgs,
+  nodeData
+}) {
+  let initialState = initialStateFromArgs ?? {};
+  for (const node of nodeData) {
+    if ('children' in node) {
+      initialState = await buildInitialState({
+        context,
+        initialState,
+        nodeData: node.children
+      });
+    }
+    if (node.type === 'block' || node.type === 'inlineBlock') {
+      const blockNode = node;
+      const id = blockNode?.fields?.id;
+      if (!id) {
+        continue;
+      }
+      const schemaFieldsPath = node.type === 'block' ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields` : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`;
+      // Build form state for the block
+      const formStateResult = await fieldSchemasToFormState({
+        id: context.id,
+        clientFieldSchemaMap: context.clientFieldSchemaMap,
+        collectionSlug: context.collectionSlug,
+        data: blockNode.fields,
+        documentData: context.documentData,
+        fields: context.fieldSchemaMap.get(schemaFieldsPath)?.fields,
+        fieldSchemaMap: context.fieldSchemaMap,
+        initialBlockData: blockNode.fields,
+        operation: context.operation,
+        permissions: true,
+        preferences: context.preferences,
+        readOnly: context.disabled,
+        renderAllFields: true,
+        renderFieldFn: context.renderFieldFn,
+        req: context.req,
+        schemaPath: schemaFieldsPath
+      });
+      if (!initialState[id]) {
+        initialState[id] = {};
+      }
+      initialState[id].formState = formStateResult;
+      if (node.type === 'block') {
+        const currentFieldPreferences = context.preferences?.fields?.[context.field.name];
+        const collapsedArray = currentFieldPreferences?.collapsed;
+        if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {
+          initialState[id].collapsed = true;
+        }
+      }
+    }
+  }
+  return initialState;
+}
+//# sourceMappingURL=buildInitialState.js.map

package/dist/utilities/buildInitialState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInitialState.js","names":["fieldSchemasToFormState","buildInitialState","context","initialState","initialStateFromArgs","nodeData","node","children","type","blockNode","id","fields","schemaFieldsPath","lexicalFieldSchemaPath","blockType","formStateResult","clientFieldSchemaMap","collectionSlug","data","documentData","fieldSchemaMap","get","initialBlockData","operation","permissions","preferences","readOnly","disabled","renderAllFields","renderFieldFn","req","schemaPath","formState","currentFieldPreferences","field","name","collapsedArray","collapsed","Array","isArray","includes"],"sources":["../../src/utilities/buildInitialState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type {\n  ClientFieldSchemaMap,\n  DocumentPreferences,\n  FieldSchemaMap,\n  FormState,\n  Operation,\n  PayloadRequest,\n  RichTextField,\n  SanitizedFieldPermissions,\n} from '@ruya.sa/payload'\n\nimport { fieldSchemasToFormState } from '@ruya.sa/ui/forms/fieldSchemasToFormState'\n\nimport type { SerializedBlockNode } from '../nodeTypes.js'\n\nexport type InitialLexicalFormState = {\n  [nodeID: string]: {\n    [key: string]: any\n    formState?: FormState\n  }\n}\n\ntype Props = {\n  context: {\n    clientFieldSchemaMap: ClientFieldSchemaMap\n    collectionSlug: string\n    disabled?: boolean\n    documentData?: any\n    field: RichTextField\n    fieldSchemaMap: FieldSchemaMap\n    id?: number | string\n    lexicalFieldSchemaPath: string\n    operation: Operation\n    permissions?: SanitizedFieldPermissions\n    preferences: DocumentPreferences\n    renderFieldFn: any\n    req: PayloadRequest\n  }\n  initialState?: InitialLexicalFormState\n  nodeData: SerializedLexicalNode[]\n}\n\nexport async function buildInitialState({\n  context,\n  initialState: initialStateFromArgs,\n  nodeData,\n}: Props): Promise<InitialLexicalFormState> {\n  let initialState: InitialLexicalFormState = initialStateFromArgs ?? {}\n  for (const node of nodeData) {\n    if ('children' in node) {\n      initialState = await buildInitialState({\n        context,\n        initialState,\n        nodeData: node.children as SerializedLexicalNode[],\n      })\n    }\n\n    if (node.type === 'block' || node.type === 'inlineBlock') {\n      const blockNode = node as SerializedBlockNode\n      const id = blockNode?.fields?.id\n      if (!id) {\n        continue\n      }\n\n      const schemaFieldsPath =\n        node.type === 'block'\n          ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields`\n          : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`\n\n      // Build form state for the block\n\n      const formStateResult = await fieldSchemasToFormState({\n        id: context.id,\n        clientFieldSchemaMap: context.clientFieldSchemaMap,\n        collectionSlug: context.collectionSlug,\n        data: blockNode.fields,\n        documentData: context.documentData,\n        fields: (context.fieldSchemaMap.get(schemaFieldsPath) as any)?.fields,\n        fieldSchemaMap: context.fieldSchemaMap,\n        initialBlockData: blockNode.fields,\n        operation: context.operation as any, // TODO: Type\n        permissions: true,\n        preferences: context.preferences,\n        readOnly: context.disabled,\n        renderAllFields: true, // If this function runs, the parent lexical field is being re-rendered => thus we can assume all its sub-fields need to be re-rendered\n        renderFieldFn: context.renderFieldFn,\n        req: context.req,\n        schemaPath: schemaFieldsPath,\n      })\n\n      if (!initialState[id]) {\n        initialState[id] = {}\n      }\n\n      initialState[id].formState = formStateResult\n\n      if (node.type === 'block') {\n        const currentFieldPreferences = context.preferences?.fields?.[context.field.name]\n        const collapsedArray = currentFieldPreferences?.collapsed\n        if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {\n          initialState[id].collapsed = true\n        }\n      }\n    }\n  }\n  return initialState\n}\n"],"mappings":"AAYA,SAASA,uBAAuB,QAAQ;AA+BxC,OAAO,eAAeC,kBAAkB;EACtCC,OAAO;EACPC,YAAA,EAAcC,oBAAoB;EAClCC;AAAQ,CACF;EACN,IAAIF,YAAA,GAAwCC,oBAAA,IAAwB,CAAC;EACrE,KAAK,MAAME,IAAA,IAAQD,QAAA,EAAU;IAC3B,IAAI,cAAcC,IAAA,EAAM;MACtBH,YAAA,GAAe,MAAMF,iBAAA,CAAkB;QACrCC,OAAA;QACAC,YAAA;QACAE,QAAA,EAAUC,IAAA,CAAKC;MACjB;IACF;IAEA,IAAID,IAAA,CAAKE,IAAI,KAAK,WAAWF,IAAA,CAAKE,IAAI,KAAK,eAAe;MACxD,MAAMC,SAAA,GAAYH,IAAA;MAClB,MAAMI,EAAA,GAAKD,SAAA,EAAWE,MAAA,EAAQD,EAAA;MAC9B,IAAI,CAACA,EAAA,EAAI;QACP;MACF;MAEA,MAAME,gBAAA,GACJN,IAAA,CAAKE,IAAI,KAAK,UACV,GAAGN,OAAA,CAAQW,sBAAsB,mDAAmDJ,SAAA,CAAUE,MAAM,CAACG,SAAS,SAAS,GACvH,GAAGZ,OAAA,CAAQW,sBAAsB,0DAA0DJ,SAAA,CAAUE,MAAM,CAACG,SAAS,SAAS;MAEpI;MAEA,MAAMC,eAAA,GAAkB,MAAMf,uBAAA,CAAwB;QACpDU,EAAA,EAAIR,OAAA,CAAQQ,EAAE;QACdM,oBAAA,EAAsBd,OAAA,CAAQc,oBAAoB;QAClDC,cAAA,EAAgBf,OAAA,CAAQe,cAAc;QACtCC,IAAA,EAAMT,SAAA,CAAUE,MAAM;QACtBQ,YAAA,EAAcjB,OAAA,CAAQiB,YAAY;QAClCR,MAAA,EAAST,OAAA,CAAQkB,cAAc,CAACC,GAAG,CAACT,gBAAA,GAA2BD,MAAA;QAC/DS,cAAA,EAAgBlB,OAAA,CAAQkB,cAAc;QACtCE,gBAAA,EAAkBb,SAAA,CAAUE,MAAM;QAClCY,SAAA,EAAWrB,OAAA,CAAQqB,SAAS;QAC5BC,WAAA,EAAa;QACbC,WAAA,EAAavB,OAAA,CAAQuB,WAAW;QAChCC,QAAA,EAAUxB,OAAA,CAAQyB,QAAQ;QAC1BC,eAAA,EAAiB;QACjBC,aAAA,EAAe3B,OAAA,CAAQ2B,aAAa;QACpCC,GAAA,EAAK5B,OAAA,CAAQ4B,GAAG;QAChBC,UAAA,EAAYnB;MACd;MAEA,IAAI,CAACT,YAAY,CAACO,EAAA,CAAG,EAAE;QACrBP,YAAY,CAACO,EAAA,CAAG,GAAG,CAAC;MACtB;MAEAP,YAAY,CAACO,EAAA,CAAG,CAACsB,SAAS,GAAGjB,eAAA;MAE7B,IAAIT,IAAA,CAAKE,IAAI,KAAK,SAAS;QACzB,MAAMyB,uBAAA,GAA0B/B,OAAA,CAAQuB,WAAW,EAAEd,MAAA,GAAST,OAAA,CAAQgC,KAAK,CAACC,IAAI,CAAC;QACjF,MAAMC,cAAA,GAAiBH,uBAAA,EAAyBI,SAAA;QAChD,IAAIC,KAAA,CAAMC,OAAO,CAACH,cAAA,KAAmBA,cAAA,CAAeI,QAAQ,CAAC9B,EAAA,GAAK;UAChEP,YAAY,CAACO,EAAA,CAAG,CAAC2B,SAAS,GAAG;QAC/B;MACF;IACF;EACF;EACA,OAAOlC,YAAA;AACT","ignoreList":[]}

package/dist/utilities/createClientFeature.d.ts

@@ -0,0 +1,18 @@
+import type { ClientConfig, RichTextFieldClient } from '@ruya.sa/payload';
+import type { BaseClientFeatureProps, ClientFeature, ClientFeatureProviderMap, FeatureProviderProviderClient, ResolvedClientFeatureMap } from '../features/typesClient.js';
+import type { ClientEditorConfig } from '../lexical/config/types.js';
+import type { FeatureClientSchemaMap } from '../types.js';
+export type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> = ((props: {
+    config: ClientConfig;
+    featureClientImportMap: Record<string, any>;
+    featureClientSchemaMap: FeatureClientSchemaMap;
+    /** unSanitizedEditorConfig.features, but mapped */
+    featureProviderMap: ClientFeatureProviderMap;
+    field?: RichTextFieldClient;
+    props: BaseClientFeatureProps<UnSanitizedClientProps>;
+    resolvedFeatures: ResolvedClientFeatureMap;
+    schemaPath: string;
+    unSanitizedEditorConfig: ClientEditorConfig;
+}) => ClientFeature<ClientProps>) | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>;
+export declare const createClientFeature: <UnSanitizedClientProps = undefined, ClientProps = UnSanitizedClientProps>(args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>) => FeatureProviderProviderClient<UnSanitizedClientProps, 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,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAEzE,OAAO,KAAK,EACV,sBAAsB,EACtB,aAAa,EACb,wBAAwB,EAExB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AACpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAEzD,MAAM,MAAM,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,IACnE,CAAC,CAAC,KAAK,EAAE;IACP,MAAM,EAAE,YAAY,CAAA;IACpB,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3C,sBAAsB,EAAE,sBAAsB,CAAA;IAC9C,mDAAmD;IACnD,kBAAkB,EAAE,wBAAwB,CAAA;IAC5C,KAAK,CAAC,EAAE,mBAAmB,CAAA;IAC3B,KAAK,EAAE,sBAAsB,CAAC,sBAAsB,CAAC,CAAA;IAErD,gBAAgB,EAAE,wBAAwB,CAAA;IAC1C,UAAU,EAAE,MAAM,CAAA;IAElB,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,6BAA6B,CAAC,sBAAsB,EAAE,WAAW,CAmDrE,CAAA"}

package/dist/utilities/createClientFeature.js

@@ -0,0 +1,51 @@
+export const createClientFeature = feature => {
+  const featureProviderProvideClient = props => {
+    const featureProviderClient = {
+      clientFeatureProps: props
+    };
+    if (typeof feature === 'function') {
+      featureProviderClient.feature = ({
+        config,
+        featureClientImportMap,
+        featureClientSchemaMap,
+        featureProviderMap,
+        field,
+        resolvedFeatures,
+        schemaPath,
+        unSanitizedEditorConfig
+      }) => {
+        const toReturn = feature({
+          config,
+          featureClientImportMap,
+          featureClientSchemaMap,
+          featureProviderMap,
+          field,
+          props,
+          resolvedFeatures,
+          schemaPath,
+          unSanitizedEditorConfig
+        });
+        if (toReturn.sanitizedClientFeatureProps === null) {
+          toReturn.sanitizedClientFeatureProps = props;
+        }
+        return toReturn;
+      };
+    } else {
+      // We have to spread feature here! Otherwise, if the arg of createClientFeature is not a function, and 2
+      // richText editors have the same feature (even if both call it, e.g. both call UploadFeature()),
+      // the second richText editor here will override sanitizedClientFeatureProps of the first feature, as both richText
+      // editor features share the same reference to the feature object.
+      // Example: richText editor 1 and 2 both have UploadFeature. richText editor 1 calls UploadFeature() with custom fields,
+      // richText editor 2 calls UploadFeature() with NO custom fields. If we don't spread feature here, richText editor 1
+      // will not have any custom fields, as richText editor 2 will override the feature object.
+      const newFeature = {
+        ...feature
+      };
+      newFeature.sanitizedClientFeatureProps = props;
+      featureProviderClient.feature = newFeature;
+    }
+    return featureProviderClient;
+  };
+  return featureProviderProvideClient;
+};
+//# sourceMappingURL=createClientFeature.js.map

package/dist/utilities/createClientFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClientFeature.js","names":["createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","config","featureClientImportMap","featureClientSchemaMap","featureProviderMap","field","resolvedFeatures","schemaPath","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps","newFeature"],"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type { ClientConfig, RichTextFieldClient } from '@ruya.sa/payload'\n\nimport type {\n  BaseClientFeatureProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  ResolvedClientFeatureMap,\n} from '../features/typesClient.js'\nimport type { ClientEditorConfig } from '../lexical/config/types.js'\nimport type { FeatureClientSchemaMap } from '../types.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      config: ClientConfig\n      featureClientImportMap: Record<string, any>\n      featureClientSchemaMap: FeatureClientSchemaMap\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      field?: RichTextFieldClient\n      props: BaseClientFeatureProps<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      schemaPath: string\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) => FeatureProviderProviderClient<UnSanitizedClientProps, 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        config,\n        featureClientImportMap,\n        featureClientSchemaMap,\n        featureProviderMap,\n        field,\n        resolvedFeatures,\n        schemaPath,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          config,\n          featureClientImportMap,\n          featureClientSchemaMap,\n          featureProviderMap,\n          field,\n          props,\n          resolvedFeatures,\n          schemaPath,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedClientFeatureProps === null) {\n          toReturn.sanitizedClientFeatureProps = props\n        }\n\n        return toReturn\n      }\n    } else {\n      // We have to spread feature here! Otherwise, if the arg of createClientFeature is not a function, and 2\n      // richText editors have the same feature (even if both call it, e.g. both call UploadFeature()),\n      // the second richText editor here will override sanitizedClientFeatureProps of the first feature, as both richText\n      // editor features share the same reference to the feature object.\n      // Example: richText editor 1 and 2 both have UploadFeature. richText editor 1 calls UploadFeature() with custom fields,\n      // richText editor 2 calls UploadFeature() with NO custom fields. If we don't spread feature here, richText editor 1\n      // will not have any custom fields, as richText editor 2 will override the feature object.\n      const newFeature: ClientFeature<any> = { ...feature }\n      newFeature.sanitizedClientFeatureProps = props\n      featureProviderClient.feature = newFeature\n    }\n    return featureProviderClient as FeatureProviderClient<any, any>\n  }\n\n  return featureProviderProvideClient\n}\n"],"mappings":"AA8BA,OAAO,MAAMA,mBAAA,GAK8DC,OAAA;EACzE,MAAMC,4BAAA,GAAyEC,KAAA;IAC7E,MAAMC,qBAAA,GAAkE;MACtEC,kBAAA,EAAoBF;IACtB;IAEA,IAAI,OAAOF,OAAA,KAAY,YAAY;MACjCG,qBAAA,CAAsBH,OAAO,GAAG,CAAC;QAC/BK,MAAM;QACNC,sBAAsB;QACtBC,sBAAsB;QACtBC,kBAAkB;QAClBC,KAAK;QACLC,gBAAgB;QAChBC,UAAU;QACVC;MAAuB,CACxB;QACC,MAAMC,QAAA,GAAWb,OAAA,CAAQ;UACvBK,MAAA;UACAC,sBAAA;UACAC,sBAAA;UACAC,kBAAA;UACAC,KAAA;UACAP,KAAA;UACAQ,gBAAA;UACAC,UAAA;UACAC;QACF;QAEA,IAAIC,QAAA,CAASC,2BAA2B,KAAK,MAAM;UACjDD,QAAA,CAASC,2BAA2B,GAAGZ,KAAA;QACzC;QAEA,OAAOW,QAAA;MACT;IACF,OAAO;MACL;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAME,UAAA,GAAiC;QAAE,GAAGf;MAAQ;MACpDe,UAAA,CAAWD,2BAA2B,GAAGZ,KAAA;MACzCC,qBAAA,CAAsBH,OAAO,GAAGe,UAAA;IAClC;IACA,OAAOZ,qBAAA;EACT;EAEA,OAAOF,4BAAA;AACT","ignoreList":[]}

package/dist/utilities/createServerFeature.d.ts

@@ -0,0 +1,17 @@
+import type { SanitizedConfig } from '@ruya.sa/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> = {
+    feature: ((props: {
+        config: SanitizedConfig;
+        /** unSanitizedEditorConfig.features, but mapped */
+        featureProviderMap: ServerFeatureProviderMap;
+        isRoot?: boolean;
+        parentIsLocalized: boolean;
+        props: UnSanitizedProps;
+        resolvedFeatures: ResolvedServerFeatureMap;
+        unSanitizedEditorConfig: ServerEditorConfig;
+    }) => Promise<ServerFeature<SanitizedProps, ClientProps>> | ServerFeature<SanitizedProps, ClientProps>) | Omit<ServerFeature<SanitizedProps, ClientProps>, 'sanitizedServerFeatureProps'>;
+} & Pick<FeatureProviderServer<UnSanitizedProps, ClientProps>, 'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'>;
+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,kBAAkB,CAAA;AAEvD,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;IACnF,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,iBAAiB,EAAE,OAAO,CAAA;QAC1B,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,GAAG,IAAI,CACN,qBAAqB,CAAC,gBAAgB,EAAE,WAAW,CAAC,EACpD,cAAc,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,KAAK,CACrE,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,CAmD/E,CAAA"}

package/dist/utilities/createServerFeature.js

@@ -0,0 +1,51 @@
+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,
+        parentIsLocalized,
+        resolvedFeatures,
+        unSanitizedEditorConfig
+      }) => {
+        const toReturn = await feature({
+          config,
+          featureProviderMap,
+          isRoot,
+          parentIsLocalized,
+          props,
+          resolvedFeatures,
+          unSanitizedEditorConfig
+        });
+        if (toReturn.sanitizedServerFeatureProps === null) {
+          toReturn.sanitizedServerFeatureProps = props;
+        }
+        return toReturn;
+      };
+    } else {
+      // For explanation why we have to spread feature, see createClientFeature.ts
+      const newFeature = {
+        ...feature
+      };
+      newFeature.sanitizedServerFeatureProps = props;
+      featureProviderServer.feature = newFeature;
+    }
+    return featureProviderServer;
+  };
+  return featureProviderProviderServer;
+};
+//# sourceMappingURL=createServerFeature.js.map

package/dist/utilities/createServerFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerFeature.js","names":["createServerFeature","dependencies","dependenciesPriority","dependenciesSoft","feature","key","featureProviderProviderServer","props","featureProviderServer","serverFeatureProps","config","featureProviderMap","isRoot","parentIsLocalized","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedServerFeatureProps","newFeature"],"sources":["../../src/utilities/createServerFeature.ts"],"sourcesContent":["import type { SanitizedConfig } from '@ruya.sa/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> = {\n  feature:\n    | ((props: {\n        config: SanitizedConfig\n        /** unSanitizedEditorConfig.features, but mapped */\n        featureProviderMap: ServerFeatureProviderMap\n        isRoot?: boolean\n        parentIsLocalized: 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} & Pick<\n  FeatureProviderServer<UnSanitizedProps, ClientProps>,\n  'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'\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        parentIsLocalized,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = await feature({\n          config,\n          featureProviderMap,\n          isRoot,\n          parentIsLocalized,\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      // For explanation why we have to spread feature, see createClientFeature.ts\n      const newFeature: ServerFeature<any, any> = { ...feature }\n\n      newFeature.sanitizedServerFeatureProps = props\n      featureProviderServer.feature = newFeature\n    }\n    return featureProviderServer as FeatureProviderServer<any, any, any>\n  }\n\n  return featureProviderProviderServer\n}\n"],"mappings":"AAiCA,OAAO,MAAMA,mBAAA,GAMuEA,CAAC;EACnFC,YAAY;EACZC,oBAAoB;EACpBC,gBAAgB;EAChBC,OAAO;EACPC;AAAG,CACJ;EACC,MAAMC,6BAAA,GAA+EC,KAAA;IACnF,MAAMC,qBAAA,GAAuE;MAC3EP,YAAA;MACAC,oBAAA;MACAC,gBAAA;MACAE,GAAA;MACAI,kBAAA,EAAoBF;IACtB;IAEA,IAAI,OAAOH,OAAA,KAAY,YAAY;MACjCI,qBAAA,CAAsBJ,OAAO,GAAG,OAAO;QACrCM,MAAM;QACNC,kBAAkB;QAClBC,MAAM;QACNC,iBAAiB;QACjBC,gBAAgB;QAChBC;MAAuB,CACxB;QACC,MAAMC,QAAA,GAAW,MAAMZ,OAAA,CAAQ;UAC7BM,MAAA;UACAC,kBAAA;UACAC,MAAA;UACAC,iBAAA;UACAN,KAAA;UACAO,gBAAA;UACAC;QACF;QAEA,IAAIC,QAAA,CAASC,2BAA2B,KAAK,MAAM;UACjDD,QAAA,CAASC,2BAA2B,GAAGV,KAAA;QACzC;QACA,OAAOS,QAAA;MACT;IACF,OAAO;MACL;MACA,MAAME,UAAA,GAAsC;QAAE,GAAGd;MAAQ;MAEzDc,UAAA,CAAWD,2BAA2B,GAAGV,KAAA;MACzCC,qBAAA,CAAsBJ,OAAO,GAAGc,UAAA;IAClC;IACA,OAAOV,qBAAA;EACT;EAEA,OAAOF,6BAAA;AACT","ignoreList":[]}

package/dist/utilities/editorConfigFactory.d.ts

@@ -0,0 +1,57 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
+import type { RichTextField, SanitizedConfig } from '@ruya.sa/payload';
+import type { FeatureProviderServer, ResolvedServerFeatureMap } from '../features/typesServer.js';
+import type { SanitizedServerEditorConfig } from '../lexical/config/types.js';
+import type { FeaturesInput, LexicalRichTextAdapterProvider } from '../types.js';
+export declare const editorConfigFactory: {
+    default: (args: {
+        config: SanitizedConfig;
+        parentIsLocalized?: boolean;
+    }) => Promise<SanitizedServerEditorConfig>;
+    /**
+     * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),
+     * you can extract the editor config from it.
+     * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.
+     *
+     * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg
+     * into a separate variable and use `fromFeatures` instead.
+     */
+    fromEditor: (args: {
+        config: SanitizedConfig;
+        editor: LexicalRichTextAdapterProvider;
+        isRoot?: boolean;
+        lexical?: LexicalEditorConfig;
+        parentIsLocalized?: boolean;
+    }) => Promise<SanitizedServerEditorConfig>;
+    /**
+     * Create a new editor config - behaves just like instantiating a new `lexicalEditor`
+     */
+    fromFeatures: (args: {
+        config: SanitizedConfig;
+        features?: FeaturesInput;
+        isRoot?: boolean;
+        lexical?: LexicalEditorConfig;
+        parentIsLocalized?: boolean;
+    }) => Promise<SanitizedServerEditorConfig>;
+    fromField: (args: {
+        field: RichTextField;
+    }) => SanitizedServerEditorConfig;
+    fromUnsanitizedField: (args: {
+        config: SanitizedConfig;
+        field: RichTextField;
+        isRoot?: boolean;
+        parentIsLocalized?: boolean;
+    }) => Promise<SanitizedServerEditorConfig>;
+};
+export declare const featuresInputToEditorConfig: (args: {
+    config: SanitizedConfig;
+    features?: FeaturesInput;
+    isRoot?: boolean;
+    lexical?: LexicalEditorConfig;
+    parentIsLocalized?: boolean;
+}) => Promise<{
+    features: FeatureProviderServer<unknown, unknown, unknown>[];
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+    sanitizedConfig: SanitizedServerEditorConfig;
+}>;
+//# sourceMappingURL=editorConfigFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editorConfigFactory.d.ts","sourceRoot":"","sources":["../../src/utilities/editorConfigFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAClE,OAAO,KAAK,EAA2B,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE/F,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AACjG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAC7E,OAAO,KAAK,EACV,aAAa,EAEb,8BAA8B,EAC/B,MAAM,aAAa,CAAA;AAOpB,eAAO,MAAM,mBAAmB;oBACR;QACpB,MAAM,EAAE,eAAe,CAAA;QACvB,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAC5B,KAAG,OAAO,CAAC,2BAA2B,CAAC;IAMxC;;;;;;;OAOG;uBACsB;QACvB,MAAM,EAAE,eAAe,CAAA;QACvB,MAAM,EAAE,8BAA8B,CAAA;QACtC,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,OAAO,CAAC,EAAE,mBAAmB,CAAA;QAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAC5B,KAAG,OAAO,CAAC,2BAA2B,CAAC;IAUxC;;OAEG;yBACwB;QACzB,MAAM,EAAE,eAAe,CAAA;QACvB,QAAQ,CAAC,EAAE,aAAa,CAAA;QACxB,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,OAAO,CAAC,EAAE,mBAAmB,CAAA;QAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAC5B,KAAG,OAAO,CAAC,2BAA2B,CAAC;sBAGtB;QAAE,KAAK,EAAE,aAAa,CAAA;KAAE,KAAG,2BAA2B;iCAMrC;QACjC,MAAM,EAAE,eAAe,CAAA;QACvB,KAAK,EAAE,aAAa,CAAA;QACpB,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAC5B,KAAG,OAAO,CAAC,2BAA2B,CAAC;CAazC,CAAA;AAED,eAAO,MAAM,2BAA2B,SAAgB;IACtD,MAAM,EAAE,eAAe,CAAA;IACvB,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,mBAAmB,CAAA;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,KAAG,OAAO,CAAC;IACV,QAAQ,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IAC5D,kBAAkB,EAAE,wBAAwB,CAAA;IAC5C,eAAe,EAAE,2BAA2B,CAAA;CAC7C,CAyCA,CAAA"}

package/dist/utilities/editorConfigFactory.js

@@ -0,0 +1,89 @@
+import { defaultEditorConfig, defaultEditorFeatures } from '../lexical/config/server/default.js';
+import { loadFeatures } from '../lexical/config/server/loader.js';
+import { sanitizeServerFeatures } from '../lexical/config/server/sanitize.js';
+import { getDefaultSanitizedEditorConfig } from './getDefaultSanitizedEditorConfig.js';
+export const editorConfigFactory = {
+  default: async args => {
+    return getDefaultSanitizedEditorConfig({
+      config: args.config,
+      parentIsLocalized: args.parentIsLocalized ?? false
+    });
+  },
+  /**
+  * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),
+  * you can extract the editor config from it.
+  * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.
+  *
+  * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg
+  * into a separate variable and use `fromFeatures` instead.
+  */
+  fromEditor: async args => {
+    const lexicalAdapter = await args.editor({
+      config: args.config,
+      isRoot: args.isRoot ?? false,
+      parentIsLocalized: args.parentIsLocalized ?? false
+    });
+    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+    return sanitizedServerEditorConfig;
+  },
+  /**
+  * Create a new editor config - behaves just like instantiating a new `lexicalEditor`
+  */
+  fromFeatures: async args => {
+    return (await featuresInputToEditorConfig(args)).sanitizedConfig;
+  },
+  fromField: args => {
+    const lexicalAdapter = args.field.editor;
+    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+    return sanitizedServerEditorConfig;
+  },
+  fromUnsanitizedField: async args => {
+    const lexicalAdapterProvider = args.field.editor;
+    const lexicalAdapter = await lexicalAdapterProvider({
+      config: args.config,
+      isRoot: args.isRoot ?? false,
+      parentIsLocalized: args.parentIsLocalized ?? false
+    });
+    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+    return sanitizedServerEditorConfig;
+  }
+};
+export const featuresInputToEditorConfig = async args => {
+  let features = [];
+  if (args.features && typeof args.features === 'function') {
+    const rootEditor = args.config.editor;
+    let rootEditorFeatures = [];
+    if (typeof rootEditor === 'object' && 'features' in rootEditor) {
+      rootEditorFeatures = rootEditor.features;
+    }
+    features = args.features({
+      defaultFeatures: defaultEditorFeatures,
+      rootFeatures: rootEditorFeatures
+    });
+  } else {
+    features = args.features;
+  }
+  if (!features) {
+    features = defaultEditorFeatures;
+  }
+  const lexical = args.lexical ?? defaultEditorConfig.lexical;
+  const resolvedFeatureMap = await loadFeatures({
+    config: args.config,
+    isRoot: args.isRoot ?? false,
+    parentIsLocalized: args.parentIsLocalized ?? false,
+    unSanitizedEditorConfig: {
+      features,
+      lexical
+    }
+  });
+  return {
+    features,
+    resolvedFeatureMap,
+    sanitizedConfig: {
+      features: sanitizeServerFeatures(resolvedFeatureMap),
+      lexical: args.lexical,
+      resolvedFeatureMap
+    }
+  };
+};
+//# sourceMappingURL=editorConfigFactory.js.map

package/dist/utilities/editorConfigFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorConfigFactory.js","names":["defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerFeatures","getDefaultSanitizedEditorConfig","editorConfigFactory","default","args","config","parentIsLocalized","fromEditor","lexicalAdapter","editor","isRoot","sanitizedServerEditorConfig","editorConfig","fromFeatures","featuresInputToEditorConfig","sanitizedConfig","fromField","field","fromUnsanitizedField","lexicalAdapterProvider","features","rootEditor","rootEditorFeatures","defaultFeatures","rootFeatures","lexical","resolvedFeatureMap","unSanitizedEditorConfig"],"sources":["../../src/utilities/editorConfigFactory.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\nimport type { RichTextAdapterProvider, RichTextField, SanitizedConfig } from '@ruya.sa/payload'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type {\n  FeaturesInput,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from '../types.js'\n\nimport { defaultEditorConfig, defaultEditorFeatures } from '../lexical/config/server/default.js'\nimport { loadFeatures } from '../lexical/config/server/loader.js'\nimport { sanitizeServerFeatures } from '../lexical/config/server/sanitize.js'\nimport { getDefaultSanitizedEditorConfig } from './getDefaultSanitizedEditorConfig.js'\n\nexport const editorConfigFactory = {\n  default: async (args: {\n    config: SanitizedConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return getDefaultSanitizedEditorConfig({\n      config: args.config,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n  },\n  /**\n   * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),\n   * you can extract the editor config from it.\n   * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.\n   *\n   * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg\n   * into a separate variable and use `fromFeatures` instead.\n   */\n  fromEditor: async (args: {\n    config: SanitizedConfig\n    editor: LexicalRichTextAdapterProvider\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapter: LexicalRichTextAdapter = await args.editor({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  /**\n   * Create a new editor config - behaves just like instantiating a new `lexicalEditor`\n   */\n  fromFeatures: async (args: {\n    config: SanitizedConfig\n    features?: FeaturesInput\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return (await featuresInputToEditorConfig(args)).sanitizedConfig\n  },\n  fromField: (args: { field: RichTextField }): SanitizedServerEditorConfig => {\n    const lexicalAdapter: LexicalRichTextAdapter = args.field.editor as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  fromUnsanitizedField: async (args: {\n    config: SanitizedConfig\n    field: RichTextField\n    isRoot?: boolean\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapterProvider: RichTextAdapterProvider = args.field\n      .editor as RichTextAdapterProvider\n\n    const lexicalAdapter: LexicalRichTextAdapter = (await lexicalAdapterProvider({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })) as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n}\n\nexport const featuresInputToEditorConfig = async (args: {\n  config: SanitizedConfig\n  features?: FeaturesInput\n  isRoot?: boolean\n  lexical?: LexicalEditorConfig\n  parentIsLocalized?: boolean\n}): Promise<{\n  features: FeatureProviderServer<unknown, unknown, unknown>[]\n  resolvedFeatureMap: ResolvedServerFeatureMap\n  sanitizedConfig: SanitizedServerEditorConfig\n}> => {\n  let features: FeatureProviderServer<unknown, unknown, unknown>[] = []\n  if (args.features && typeof args.features === 'function') {\n    const rootEditor = args.config.editor\n    let rootEditorFeatures: FeatureProviderServer<unknown, unknown, unknown>[] = []\n    if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n      rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n    }\n    features = args.features({\n      defaultFeatures: defaultEditorFeatures,\n      rootFeatures: rootEditorFeatures,\n    })\n  } else {\n    features = args.features as FeatureProviderServer<unknown, unknown, unknown>[]\n  }\n\n  if (!features) {\n    features = defaultEditorFeatures\n  }\n\n  const lexical = args.lexical ?? defaultEditorConfig.lexical\n\n  const resolvedFeatureMap = await loadFeatures({\n    config: args.config,\n    isRoot: args.isRoot ?? false,\n    parentIsLocalized: args.parentIsLocalized ?? false,\n    unSanitizedEditorConfig: {\n      features,\n      lexical,\n    },\n  })\n\n  return {\n    features,\n    resolvedFeatureMap,\n    sanitizedConfig: {\n      features: sanitizeServerFeatures(resolvedFeatureMap),\n      lexical: args.lexical,\n      resolvedFeatureMap,\n    },\n  }\n}\n"],"mappings":"AAWA,SAASA,mBAAmB,EAAEC,qBAAqB,QAAQ;AAC3D,SAASC,YAAY,QAAQ;AAC7B,SAASC,sBAAsB,QAAQ;AACvC,SAASC,+BAA+B,QAAQ;AAEhD,OAAO,MAAMC,mBAAA,GAAsB;EACjCC,OAAA,EAAS,MAAOC,IAAA;IAId,OAAOH,+BAAA,CAAgC;MACrCI,MAAA,EAAQD,IAAA,CAAKC,MAAM;MACnBC,iBAAA,EAAmBF,IAAA,CAAKE,iBAAiB,IAAI;IAC/C;EACF;EACA;;;;;;;;EAQAC,UAAA,EAAY,MAAOH,IAAA;IAOjB,MAAMI,cAAA,GAAyC,MAAMJ,IAAA,CAAKK,MAAM,CAAC;MAC/DJ,MAAA,EAAQD,IAAA,CAAKC,MAAM;MACnBK,MAAA,EAAQN,IAAA,CAAKM,MAAM,IAAI;MACvBJ,iBAAA,EAAmBF,IAAA,CAAKE,iBAAiB,IAAI;IAC/C;IAEA,MAAMK,2BAAA,GAA2DH,cAAA,CAAeI,YAAY;IAC5F,OAAOD,2BAAA;EACT;EACA;;;EAGAE,YAAA,EAAc,MAAOT,IAAA;IAOnB,OAAO,CAAC,MAAMU,2BAAA,CAA4BV,IAAA,CAAI,EAAGW,eAAe;EAClE;EACAC,SAAA,EAAYZ,IAAA;IACV,MAAMI,cAAA,GAAyCJ,IAAA,CAAKa,KAAK,CAACR,MAAM;IAEhE,MAAME,2BAAA,GAA2DH,cAAA,CAAeI,YAAY;IAC5F,OAAOD,2BAAA;EACT;EACAO,oBAAA,EAAsB,MAAOd,IAAA;IAM3B,MAAMe,sBAAA,GAAkDf,IAAA,CAAKa,KAAK,CAC/DR,MAAM;IAET,MAAMD,cAAA,GAA0C,MAAMW,sBAAA,CAAuB;MAC3Ed,MAAA,EAAQD,IAAA,CAAKC,MAAM;MACnBK,MAAA,EAAQN,IAAA,CAAKM,MAAM,IAAI;MACvBJ,iBAAA,EAAmBF,IAAA,CAAKE,iBAAiB,IAAI;IAC/C;IAEA,MAAMK,2BAAA,GAA2DH,cAAA,CAAeI,YAAY;IAC5F,OAAOD,2BAAA;EACT;AACF;AAEA,OAAO,MAAMG,2BAAA,GAA8B,MAAOV,IAAA;EAWhD,IAAIgB,QAAA,GAA+D,EAAE;EACrE,IAAIhB,IAAA,CAAKgB,QAAQ,IAAI,OAAOhB,IAAA,CAAKgB,QAAQ,KAAK,YAAY;IACxD,MAAMC,UAAA,GAAajB,IAAA,CAAKC,MAAM,CAACI,MAAM;IACrC,IAAIa,kBAAA,GAAyE,EAAE;IAC/E,IAAI,OAAOD,UAAA,KAAe,YAAY,cAAcA,UAAA,EAAY;MAC9DC,kBAAA,GAAqBD,UAAC,CAAsCD,QAAQ;IACtE;IACAA,QAAA,GAAWhB,IAAA,CAAKgB,QAAQ,CAAC;MACvBG,eAAA,EAAiBzB,qBAAA;MACjB0B,YAAA,EAAcF;IAChB;EACF,OAAO;IACLF,QAAA,GAAWhB,IAAA,CAAKgB,QAAQ;EAC1B;EAEA,IAAI,CAACA,QAAA,EAAU;IACbA,QAAA,GAAWtB,qBAAA;EACb;EAEA,MAAM2B,OAAA,GAAUrB,IAAA,CAAKqB,OAAO,IAAI5B,mBAAA,CAAoB4B,OAAO;EAE3D,MAAMC,kBAAA,GAAqB,MAAM3B,YAAA,CAAa;IAC5CM,MAAA,EAAQD,IAAA,CAAKC,MAAM;IACnBK,MAAA,EAAQN,IAAA,CAAKM,MAAM,IAAI;IACvBJ,iBAAA,EAAmBF,IAAA,CAAKE,iBAAiB,IAAI;IAC7CqB,uBAAA,EAAyB;MACvBP,QAAA;MACAK;IACF;EACF;EAEA,OAAO;IACLL,QAAA;IACAM,kBAAA;IACAX,eAAA,EAAiB;MACfK,QAAA,EAAUpB,sBAAA,CAAuB0B,kBAAA;MACjCD,OAAA,EAASrB,IAAA,CAAKqB,OAAO;MACrBC;IACF;EACF;AACF","ignoreList":[]}

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

@@ -0,0 +1,21 @@
+import type { ClientField, Data, FormState, JsonObject } from '@ruya.sa/payload';
+import React from 'react';
+export type FieldsDrawerProps = {
+    readonly className?: string;
+    readonly data?: Data;
+    readonly drawerSlug: string;
+    readonly drawerTitle?: string;
+    readonly featureKey: string;
+    readonly fieldMapOverride?: ClientField[];
+    readonly handleDrawerSubmit: (fields: FormState, data: JsonObject) => void;
+    readonly schemaFieldsPathOverride?: string;
+    readonly schemaPath: string;
+    readonly 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,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAGhF,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAA;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,EAAE,CAAA;IACzC,QAAQ,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IAC1E,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAA;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA0CpD,CAAA"}