@ruya.sa/richtext-lexical 3.71.7

package/dist/populateGraphQL/defaultValue.js

@@ -0,0 +1,28 @@
+export const defaultRichTextValue = {
+  root: {
+    type: 'root',
+    children: [{
+      type: 'paragraph',
+      children: [{
+        type: 'text',
+        detail: 0,
+        format: 0,
+        mode: 'normal',
+        style: '',
+        text: '',
+        version: 1
+      }],
+      direction: null,
+      format: '',
+      indent: 0,
+      textFormat: 0,
+      textStyle: '',
+      version: 1
+    }],
+    direction: null,
+    format: '',
+    indent: 0,
+    version: 1
+  }
+};
+//# sourceMappingURL=defaultValue.js.map

package/dist/populateGraphQL/defaultValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultValue.js","names":["defaultRichTextValue","root","type","children","detail","format","mode","style","text","version","direction","indent","textFormat","textStyle"],"sources":["../../src/populateGraphQL/defaultValue.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedParagraphNode, SerializedTextNode } from 'lexical'\n\nexport const defaultRichTextValue: SerializedEditorState = {\n  root: {\n    type: 'root',\n    children: [\n      {\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          } as SerializedTextNode,\n        ],\n        direction: null,\n        format: '',\n        indent: 0,\n        textFormat: 0,\n        textStyle: '',\n        version: 1,\n      } as SerializedParagraphNode,\n    ],\n    direction: null,\n    format: '',\n    indent: 0,\n    version: 1,\n  },\n}\n"],"mappings":"AAEA,OAAO,MAAMA,oBAAA,GAA8C;EACzDC,IAAA,EAAM;IACJC,IAAA,EAAM;IACNC,QAAA,EAAU,CACR;MACED,IAAA,EAAM;MACNC,QAAA,EAAU,CACR;QACED,IAAA,EAAM;QACNE,MAAA,EAAQ;QACRC,MAAA,EAAQ;QACRC,IAAA,EAAM;QACNC,KAAA,EAAO;QACPC,IAAA,EAAM;QACNC,OAAA,EAAS;MACX,EACD;MACDC,SAAA,EAAW;MACXL,MAAA,EAAQ;MACRM,MAAA,EAAQ;MACRC,UAAA,EAAY;MACZC,SAAA,EAAW;MACXJ,OAAA,EAAS;IACX,EACD;IACDC,SAAA,EAAW;IACXL,MAAA,EAAQ;IACRM,MAAA,EAAQ;IACRF,OAAA,EAAS;EACX;AACF","ignoreList":[]}

package/dist/populateGraphQL/populate.d.ts

@@ -0,0 +1,18 @@
+import type { PayloadRequest, SelectType } from '@ruya.sa/payload';
+type PopulateArguments = {
+    collectionSlug: string;
+    currentDepth?: number;
+    data: unknown;
+    depth: number;
+    draft: boolean;
+    id: number | string;
+    key: number | string;
+    overrideAccess: boolean;
+    req: PayloadRequest;
+    select?: SelectType;
+    showHiddenFields: boolean;
+};
+type PopulateFn = (args: PopulateArguments) => Promise<void>;
+export declare const populate: PopulateFn;
+export {};
+//# sourceMappingURL=populate.d.ts.map

package/dist/populateGraphQL/populate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAIlE,KAAK,iBAAiB,GAAG;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,cAAc,EAAE,OAAO,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,KAAK,UAAU,GAAG,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE5D,eAAO,MAAM,QAAQ,EAAE,UA0CtB,CAAA"}

package/dist/populateGraphQL/populate.js

@@ -0,0 +1,40 @@
+import { createDataloaderCacheKey } from '@ruya.sa/payload';
+export const populate = async ({
+  id,
+  collectionSlug,
+  currentDepth,
+  data,
+  depth,
+  draft,
+  key,
+  overrideAccess,
+  req,
+  select,
+  showHiddenFields
+}) => {
+  const shouldPopulate = depth && currentDepth <= depth;
+  // usually depth is checked within recursivelyPopulateFieldsForGraphQL. But since this populate function can be called outside of that (in rest afterRead node hooks) we need to check here too
+  if (!shouldPopulate) {
+    return;
+  }
+  const dataRef = data;
+  const doc = await req.payloadDataLoader?.load(createDataloaderCacheKey({
+    collectionSlug,
+    currentDepth: currentDepth + 1,
+    depth,
+    docID: id,
+    draft,
+    fallbackLocale: req.fallbackLocale,
+    locale: req.locale,
+    overrideAccess,
+    select,
+    showHiddenFields,
+    transactionID: req.transactionID
+  }));
+  if (doc) {
+    dataRef[key] = doc;
+  } else {
+    dataRef[key] = null;
+  }
+};
+//# sourceMappingURL=populate.js.map

package/dist/populateGraphQL/populate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate.js","names":["createDataloaderCacheKey","populate","id","collectionSlug","currentDepth","data","depth","draft","key","overrideAccess","req","select","showHiddenFields","shouldPopulate","dataRef","doc","payloadDataLoader","load","docID","fallbackLocale","locale","transactionID"],"sources":["../../src/populateGraphQL/populate.ts"],"sourcesContent":["import type { PayloadRequest, SelectType } from '@ruya.sa/payload'\n\nimport { createDataloaderCacheKey } from '@ruya.sa/payload'\n\ntype PopulateArguments = {\n  collectionSlug: string\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  id: number | string\n  key: number | string\n  overrideAccess: boolean\n  req: PayloadRequest\n  select?: SelectType\n  showHiddenFields: boolean\n}\n\ntype PopulateFn = (args: PopulateArguments) => Promise<void>\n\nexport const populate: PopulateFn = async ({\n  id,\n  collectionSlug,\n  currentDepth,\n  data,\n  depth,\n  draft,\n  key,\n  overrideAccess,\n  req,\n  select,\n  showHiddenFields,\n}) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n  // usually depth is checked within recursivelyPopulateFieldsForGraphQL. But since this populate function can be called outside of that (in rest afterRead node hooks) we need to check here too\n  if (!shouldPopulate) {\n    return\n  }\n\n  const dataRef = data as Record<string, unknown>\n\n  const doc = await req.payloadDataLoader?.load(\n    createDataloaderCacheKey({\n      collectionSlug,\n      currentDepth: currentDepth! + 1,\n      depth,\n      docID: id as string,\n      draft,\n      fallbackLocale: req.fallbackLocale!,\n      locale: req.locale!,\n      overrideAccess,\n      select,\n      showHiddenFields,\n      transactionID: req.transactionID!,\n    }),\n  )\n\n  if (doc) {\n    dataRef[key] = doc\n  } else {\n    dataRef[key] = null\n  }\n}\n"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ;AAkBzC,OAAO,MAAMC,QAAA,GAAuB,MAAAA,CAAO;EACzCC,EAAE;EACFC,cAAc;EACdC,YAAY;EACZC,IAAI;EACJC,KAAK;EACLC,KAAK;EACLC,GAAG;EACHC,cAAc;EACdC,GAAG;EACHC,MAAM;EACNC;AAAgB,CACjB;EACC,MAAMC,cAAA,GAAiBP,KAAA,IAASF,YAAA,IAAiBE,KAAA;EACjD;EACA,IAAI,CAACO,cAAA,EAAgB;IACnB;EACF;EAEA,MAAMC,OAAA,GAAUT,IAAA;EAEhB,MAAMU,GAAA,GAAM,MAAML,GAAA,CAAIM,iBAAiB,EAAEC,IAAA,CACvCjB,wBAAA,CAAyB;IACvBG,cAAA;IACAC,YAAA,EAAcA,YAAA,GAAgB;IAC9BE,KAAA;IACAY,KAAA,EAAOhB,EAAA;IACPK,KAAA;IACAY,cAAA,EAAgBT,GAAA,CAAIS,cAAc;IAClCC,MAAA,EAAQV,GAAA,CAAIU,MAAM;IAClBX,cAAA;IACAE,MAAA;IACAC,gBAAA;IACAS,aAAA,EAAeX,GAAA,CAAIW;EACrB;EAGF,IAAIN,GAAA,EAAK;IACPD,OAAO,CAACN,GAAA,CAAI,GAAGO,GAAA;EACjB,OAAO;IACLD,OAAO,CAACN,GAAA,CAAI,GAAG;EACjB;AACF","ignoreList":[]}

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts

@@ -0,0 +1,13 @@
+import type { SerializedEditorState } from 'lexical';
+import type { RichTextAdapter } from '@ruya.sa/payload';
+import type { PopulationPromise } from '../features/typesServer.js';
+import type { AdapterProps } from '../types.js';
+export type Args = {
+    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
+    parentIsLocalized: boolean;
+} & Parameters<NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>>[0];
+/**
+ * Appends all new populationPromises to the populationPromises prop
+ */
+export declare const populateLexicalPopulationPromises: ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, parentIsLocalized, populationPromises, req, showHiddenFields, siblingDoc, }: Args) => void;
+//# sourceMappingURL=populateLexicalPopulationPromises.d.ts.map

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,MAAM,MAAM,IAAI,GAAG;IACjB,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,iBAAiB,EAAE,OAAO,CAAA;CAC3B,GAAG,UAAU,CACZ,WAAW,CAAC,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAC/F,CAAC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,iCAAiC,iNAgB3C,IAAI,SAoCN,CAAA"}

package/dist/populateGraphQL/populateLexicalPopulationPromises.js

@@ -0,0 +1,55 @@
+import { recurseNodes } from '../utilities/forEachNodeRecursively.js';
+/**
+ * Appends all new populationPromises to the populationPromises prop
+ */
+export const populateLexicalPopulationPromises = ({
+  context,
+  currentDepth,
+  depth,
+  draft,
+  editorPopulationPromises,
+  field,
+  fieldPromises,
+  findMany,
+  flattenLocales,
+  overrideAccess,
+  parentIsLocalized,
+  populationPromises,
+  req,
+  showHiddenFields,
+  siblingDoc
+}) => {
+  const shouldPopulate = depth && currentDepth <= depth;
+  if (!shouldPopulate) {
+    return;
+  }
+  recurseNodes({
+    callback: node => {
+      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type);
+      if (editorPopulationPromisesOfNodeType) {
+        for (const promise of editorPopulationPromisesOfNodeType) {
+          promise({
+            context,
+            currentDepth: currentDepth,
+            depth,
+            draft,
+            editorPopulationPromises,
+            field,
+            fieldPromises,
+            findMany,
+            flattenLocales,
+            node,
+            overrideAccess: overrideAccess,
+            parentIsLocalized,
+            populationPromises,
+            req,
+            showHiddenFields,
+            siblingDoc
+          });
+        }
+      }
+    },
+    nodes: siblingDoc[field?.name]?.root?.children ?? []
+  });
+};
+//# sourceMappingURL=populateLexicalPopulationPromises.js.map

package/dist/populateGraphQL/populateLexicalPopulationPromises.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","editorPopulationPromisesOfNodeType","get","type","promise","nodes","name","root","children"],"sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from '@ruya.sa/payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\nimport type { AdapterProps } from '../types.js'\n\nimport { recurseNodes } from '../utilities/forEachNodeRecursively.js'\n\nexport type Args = {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  parentIsLocalized: boolean\n} & Parameters<\n  NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>\n>[0]\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n\n  if (!shouldPopulate) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type)\n      if (editorPopulationPromisesOfNodeType) {\n        for (const promise of editorPopulationPromisesOfNodeType) {\n          promise({\n            context,\n            currentDepth: currentDepth!,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess: overrideAccess!,\n            parentIsLocalized,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"mappings":"AAMA,SAASA,YAAY,QAAQ;AAS7B;;;AAGA,OAAO,MAAMC,iCAAA,GAAoCA,CAAC;EAChDC,OAAO;EACPC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,wBAAwB;EACxBC,KAAK;EACLC,aAAa;EACbC,QAAQ;EACRC,cAAc;EACdC,cAAc;EACdC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBb,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACa,cAAA,EAAgB;IACnB;EACF;EAEAjB,YAAA,CAAa;IACXkB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCd,wBAAA,EAA0Be,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNrB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAS,IAAA;YACAR,cAAA,EAAgBA,cAAA;YAChBC,iBAAA;YACAC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACT,KAAA,EAAOkB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.d.ts

@@ -0,0 +1,29 @@
+import type { Field, JsonObject, PayloadRequest, RequestContext } from '@ruya.sa/payload';
+import type { PopulationPromise } from '../features/typesServer.js';
+type NestedRichTextFieldsArgs = {
+    context: RequestContext;
+    currentDepth?: number;
+    data: unknown;
+    depth: number;
+    draft: boolean;
+    /**
+     * This maps all the population promises to the node types
+     */
+    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
+    /**
+     * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises
+     */
+    fieldPromises: Promise<void>[];
+    fields: Field[];
+    findMany: boolean;
+    flattenLocales: boolean;
+    overrideAccess: boolean;
+    parentIsLocalized: boolean;
+    populationPromises: Promise<void>[];
+    req: PayloadRequest;
+    showHiddenFields: boolean;
+    siblingDoc: JsonObject;
+};
+export declare const recursivelyPopulateFieldsForGraphQL: ({ context, currentDepth, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess, parentIsLocalized, populationPromises, req, showHiddenFields, siblingDoc, }: NestedRichTextFieldsArgs) => void;
+export {};
+//# sourceMappingURL=recursivelyPopulateFieldsForGraphQL.d.ts.map

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursivelyPopulateFieldsForGraphQL.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAIzF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,cAAc,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd;;OAEG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IAC9B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACnC,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,mCAAmC,8LAgB7C,wBAAwB,KAAG,IA0B7B,CAAA"}

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.js

@@ -0,0 +1,45 @@
+import { afterReadTraverseFields } from '@ruya.sa/payload';
+export const recursivelyPopulateFieldsForGraphQL = ({
+  context,
+  currentDepth = 0,
+  data,
+  depth,
+  draft,
+  fieldPromises,
+  fields,
+  findMany,
+  flattenLocales,
+  overrideAccess = false,
+  parentIsLocalized,
+  populationPromises,
+  req,
+  showHiddenFields,
+  siblingDoc
+}) => {
+  afterReadTraverseFields({
+    collection: null,
+    context,
+    currentDepth,
+    depth,
+    doc: data,
+    draft,
+    fallbackLocale: req.fallbackLocale,
+    fieldPromises,
+    fields,
+    findMany,
+    flattenLocales,
+    global: null,
+    locale: req.locale,
+    overrideAccess,
+    parentIndexPath: '',
+    parentIsLocalized,
+    parentPath: '',
+    parentSchemaPath: '',
+    populationPromises,
+    req,
+    showHiddenFields,
+    siblingDoc,
+    triggerHooks: false
+  });
+};
+//# sourceMappingURL=recursivelyPopulateFieldsForGraphQL.js.map

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursivelyPopulateFieldsForGraphQL.js","names":["afterReadTraverseFields","recursivelyPopulateFieldsForGraphQL","context","currentDepth","data","depth","draft","fieldPromises","fields","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","global","locale","parentIndexPath","parentPath","parentSchemaPath","triggerHooks"],"sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"sourcesContent":["import type { Field, JsonObject, PayloadRequest, RequestContext } from '@ruya.sa/payload'\n\nimport { afterReadTraverseFields } from '@ruya.sa/payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\n\ntype NestedRichTextFieldsArgs = {\n  context: RequestContext\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  /**\n   * This maps all the population promises to the node types\n   */\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  /**\n   * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises\n   */\n  fieldPromises: Promise<void>[]\n  fields: Field[]\n  findMany: boolean\n  flattenLocales: boolean\n  overrideAccess: boolean\n  parentIsLocalized: boolean\n  populationPromises: Promise<void>[]\n  req: PayloadRequest\n  showHiddenFields: boolean\n  siblingDoc: JsonObject\n}\n\nexport const recursivelyPopulateFieldsForGraphQL = ({\n  context,\n  currentDepth = 0,\n  data,\n  depth,\n  draft,\n  fieldPromises,\n  fields,\n  findMany,\n  flattenLocales,\n  overrideAccess = false,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: NestedRichTextFieldsArgs): void => {\n  afterReadTraverseFields({\n    collection: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    context,\n    currentDepth,\n    depth,\n    doc: data as any, // Looks like it's only needed for hooks and access control, so doesn't matter what we pass here right now\n    draft,\n    fallbackLocale: req.fallbackLocale!,\n    fieldPromises,\n    fields,\n    findMany,\n    flattenLocales,\n    global: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    locale: req.locale!,\n    overrideAccess,\n    parentIndexPath: '',\n    parentIsLocalized,\n    parentPath: '',\n    parentSchemaPath: '',\n    populationPromises, // This is not the same as populationPromises passed into this recurseNestedFields. These are just promises resolved at the very end.\n    req,\n    showHiddenFields,\n    siblingDoc,\n    triggerHooks: false,\n  })\n}\n"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ;AA6BxC,OAAO,MAAMC,mCAAA,GAAsCA,CAAC;EAClDC,OAAO;EACPC,YAAA,GAAe,CAAC;EAChBC,IAAI;EACJC,KAAK;EACLC,KAAK;EACLC,aAAa;EACbC,MAAM;EACNC,QAAQ;EACRC,cAAc;EACdC,cAAA,GAAiB,KAAK;EACtBC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACe;EACzBhB,uBAAA,CAAwB;IACtBiB,UAAA,EAAY;IACZf,OAAA;IACAC,YAAA;IACAE,KAAA;IACAa,GAAA,EAAKd,IAAA;IACLE,KAAA;IACAa,cAAA,EAAgBL,GAAA,CAAIK,cAAc;IAClCZ,aAAA;IACAC,MAAA;IACAC,QAAA;IACAC,cAAA;IACAU,MAAA,EAAQ;IACRC,MAAA,EAAQP,GAAA,CAAIO,MAAM;IAClBV,cAAA;IACAW,eAAA,EAAiB;IACjBV,iBAAA;IACAW,UAAA,EAAY;IACZC,gBAAA,EAAkB;IAClBX,kBAAA;IACAC,GAAA;IACAC,gBAAA;IACAC,UAAA;IACAS,YAAA,EAAc;EAChB;AACF","ignoreList":[]}

package/dist/types.d.ts

@@ -0,0 +1,109 @@
+import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical';
+import type { ClientField, DefaultServerCellComponentProps, LabelFunction, RichTextAdapter, RichTextField, RichTextFieldClient, RichTextFieldClientProps, SanitizedConfig, ServerFieldBase, StaticLabel } from '@ruya.sa/payload';
+import type { BaseClientFeatureProps, FeatureProviderProviderClient } from './features/typesClient.js';
+import type { FeatureProviderServer } from './features/typesServer.js';
+import type { SanitizedServerEditorConfig } from './lexical/config/types.js';
+import type { InitialLexicalFormState } from './utilities/buildInitialState.js';
+export type LexicalFieldAdminProps = {
+    /**
+     * Controls if the add block button should be hidden. @default false
+     */
+    hideAddBlockButton?: boolean;
+    /**
+     * Controls if the draggable block element should be hidden. @default false
+     */
+    hideDraggableBlockElement?: boolean;
+    /**
+     * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false
+     */
+    hideGutter?: boolean;
+    /**
+     * Controls if the insert paragraph at the end button should be hidden. @default false
+     */
+    hideInsertParagraphAtEnd?: boolean;
+    /**
+     * Changes the placeholder text in the editor if no content is present.
+     */
+    placeholder?: LabelFunction | StaticLabel;
+};
+export type LexicalFieldAdminClientProps = {
+    placeholder?: string;
+} & Omit<LexicalFieldAdminProps, 'placeholder'>;
+export type FeaturesInput = (({ defaultFeatures, rootFeatures, }: {
+    /**
+     * This opinionated array contains all "recommended" default features.
+     *
+     * @Example
+     *
+     * ```ts
+     *  editor: lexicalEditor({
+     *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],
+     *  })
+     *  ```
+     */
+    defaultFeatures: FeatureProviderServer<any, any, any>[];
+    /**
+     * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).
+     * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty.
+     *
+     * @Example
+     *
+     * ```ts
+     *  editor: lexicalEditor({
+     *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],
+     *  })
+     *  ```
+     */
+    rootFeatures: FeatureProviderServer<any, any, any>[];
+}) => FeatureProviderServer<any, any, any>[]) | FeatureProviderServer<any, any, any>[];
+export type LexicalEditorProps = {
+    admin?: LexicalFieldAdminProps;
+    features?: FeaturesInput;
+    lexical?: LexicalEditorConfig;
+};
+export type LexicalRichTextAdapter = {
+    editorConfig: SanitizedServerEditorConfig;
+    features: FeatureProviderServer<any, any, any>[];
+} & RichTextAdapter<SerializedEditorState, AdapterProps>;
+export type LexicalRichTextAdapterProvider = 
+/**
+ * This is being called during the payload sanitization process
+ */
+({ config, isRoot, parentIsLocalized, }: {
+    config: SanitizedConfig;
+    isRoot?: boolean;
+    parentIsLocalized: boolean;
+}) => Promise<LexicalRichTextAdapter>;
+export type SingleFeatureClientSchemaMap = {
+    [key: string]: ClientField[];
+};
+export type FeatureClientSchemaMap = {
+    [featureKey: string]: SingleFeatureClientSchemaMap;
+};
+export type LexicalRichTextFieldProps = {
+    admin?: LexicalFieldAdminClientProps;
+    clientFeatures: {
+        [featureKey: string]: {
+            clientFeatureProps?: BaseClientFeatureProps<Record<string, any>>;
+            clientFeatureProvider?: FeatureProviderProviderClient<any, any>;
+        };
+    };
+    /**
+     * Part of the import map that contains client components for all lexical features of this field that
+     * have been added through `feature.componentImports`.
+     */
+    featureClientImportMap?: Record<string, any>;
+    featureClientSchemaMap: FeatureClientSchemaMap;
+    initialLexicalFormState: InitialLexicalFormState;
+    lexicalEditorConfig: LexicalEditorConfig | undefined;
+} & Pick<ServerFieldBase, 'permissions'> & RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>;
+export type LexicalRichTextCellProps = DefaultServerCellComponentProps<RichTextFieldClient<SerializedEditorState, AdapterProps, object>, SerializedEditorState>;
+export type AdapterProps = {
+    editorConfig: SanitizedServerEditorConfig;
+};
+export type GeneratedFeatureProviderComponent = {
+    clientFeature: FeatureProviderProviderClient<any, any>;
+    clientFeatureProps: BaseClientFeatureProps<object>;
+};
+export type LexicalRichTextField = RichTextField<SerializedEditorState, AdapterProps>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical'\nimport type {\n  ClientField,\n  DefaultServerCellComponentProps,\n  LabelFunction,\n  RichTextAdapter,\n  RichTextField,\n  RichTextFieldClient,\n  RichTextFieldClientProps,\n  SanitizedConfig,\n  ServerFieldBase,\n  StaticLabel,\n} from '@ruya.sa/payload'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from './features/typesClient.js'\nimport type { FeatureProviderServer } from './features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from './lexical/config/types.js'\nimport type { InitialLexicalFormState } from './utilities/buildInitialState.js'\n\nexport type LexicalFieldAdminProps = {\n  /**\n   * Controls if the add block button should be hidden. @default false\n   */\n  hideAddBlockButton?: boolean\n  /**\n   * Controls if the draggable block element should be hidden. @default false\n   */\n  hideDraggableBlockElement?: boolean\n  /**\n   * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false\n   */\n  hideGutter?: boolean\n  /**\n   * Controls if the insert paragraph at the end button should be hidden. @default false\n   */\n  hideInsertParagraphAtEnd?: boolean\n  /**\n   * Changes the placeholder text in the editor if no content is present.\n   */\n  placeholder?: LabelFunction | StaticLabel\n}\n\nexport type LexicalFieldAdminClientProps = {\n  placeholder?: string\n} & Omit<LexicalFieldAdminProps, 'placeholder'>\n\nexport type FeaturesInput =\n  | (({\n      defaultFeatures,\n      rootFeatures,\n    }: {\n      /**\n       * This opinionated array contains all \"recommended\" default features.\n       *\n       * @Example\n       *\n       * ```ts\n       *  editor: lexicalEditor({\n       *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],\n       *  })\n       *  ```\n       */\n      defaultFeatures: FeatureProviderServer<any, any, any>[]\n      /**\n       * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).\n       * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty.\n       *\n       * @Example\n       *\n       * ```ts\n       *  editor: lexicalEditor({\n       *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],\n       *  })\n       *  ```\n       */\n      rootFeatures: FeatureProviderServer<any, any, any>[]\n    }) => FeatureProviderServer<any, any, any>[])\n  | FeatureProviderServer<any, any, any>[]\n\nexport type LexicalEditorProps = {\n  admin?: LexicalFieldAdminProps\n  features?: FeaturesInput\n  lexical?: LexicalEditorConfig\n}\n\nexport type LexicalRichTextAdapter = {\n  editorConfig: SanitizedServerEditorConfig\n  features: FeatureProviderServer<any, any, any>[]\n} & RichTextAdapter<SerializedEditorState, AdapterProps>\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({\n    config,\n    isRoot,\n    parentIsLocalized,\n  }: {\n    config: SanitizedConfig\n    isRoot?: boolean\n    parentIsLocalized: boolean\n  }) => Promise<LexicalRichTextAdapter>\n\nexport type SingleFeatureClientSchemaMap = {\n  [key: string]: ClientField[]\n}\nexport type FeatureClientSchemaMap = {\n  [featureKey: string]: SingleFeatureClientSchemaMap\n}\n\nexport type LexicalRichTextFieldProps = {\n  admin?: LexicalFieldAdminClientProps\n  // clientFeatures is added through the rsc field\n  clientFeatures: {\n    [featureKey: string]: {\n      clientFeatureProps?: BaseClientFeatureProps<Record<string, any>>\n      clientFeatureProvider?: FeatureProviderProviderClient<any, any>\n    }\n  }\n  /**\n   * Part of the import map that contains client components for all lexical features of this field that\n   * have been added through `feature.componentImports`.\n   */\n  featureClientImportMap?: Record<string, any>\n  featureClientSchemaMap: FeatureClientSchemaMap\n  initialLexicalFormState: InitialLexicalFormState\n  lexicalEditorConfig: LexicalEditorConfig | undefined // Undefined if default lexical editor config should be used\n} & Pick<ServerFieldBase, 'permissions'> &\n  RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>\n\nexport type LexicalRichTextCellProps = DefaultServerCellComponentProps<\n  RichTextFieldClient<SerializedEditorState, AdapterProps, object>,\n  SerializedEditorState\n>\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  clientFeature: FeatureProviderProviderClient<any, any>\n  clientFeatureProps: BaseClientFeatureProps<object>\n}\n\nexport type LexicalRichTextField = RichTextField<SerializedEditorState, AdapterProps>\n"],"mappings":"AAoJA","ignoreList":[]}

package/dist/utilities/applyBaseFilterToFields.d.ts

@@ -0,0 +1,10 @@
+import type { Field, SanitizedConfig } from '@ruya.sa/payload';
+/**
+ * Recursively applies baseFilter from collection config to relationship fields
+ * within blocks. This ensures that relationship drawers in blocks respect
+ * collection-level filters like multi-tenant filtering.
+ *
+ * Based on the fix from PR #13229 for LinkFeature
+ */
+export declare function applyBaseFilterToFields(fields: Field[], config: SanitizedConfig): Field[];
+//# sourceMappingURL=applyBaseFilterToFields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyBaseFilterToFields.d.ts","sourceRoot":"","sources":["../../src/utilities/applyBaseFilterToFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,KAAK,EAAE,eAAe,EAAa,MAAM,kBAAkB,CAAA;AAIhF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,KAAK,EAAE,CAiGzF"}

package/dist/utilities/applyBaseFilterToFields.js

@@ -0,0 +1,97 @@
+import { combineWhereConstraints } from '@ruya.sa/payload/shared';
+/**
+ * Recursively applies baseFilter from collection config to relationship fields
+ * within blocks. This ensures that relationship drawers in blocks respect
+ * collection-level filters like multi-tenant filtering.
+ *
+ * Based on the fix from PR #13229 for LinkFeature
+ */
+export function applyBaseFilterToFields(fields, config) {
+  return fields.map(field => {
+    // Handle relationship fields
+    if (field.type === 'relationship') {
+      const relationshipField = field;
+      // Store the original filterOptions
+      const originalFilterOptions = relationshipField.filterOptions;
+      // Create new filterOptions that includes baseFilter
+      relationshipField.filterOptions = async args => {
+        const {
+          relationTo,
+          req,
+          user
+        } = args;
+        // Call original filterOptions if it exists
+        const originalResult = typeof originalFilterOptions === 'function' ? await originalFilterOptions(args) : originalFilterOptions ?? true;
+        // If original filter returns false, respect that
+        if (originalResult === false) {
+          return false;
+        }
+        // Get the collection's admin config
+        const admin = config.collections.find(({
+          slug
+        }) => slug === relationTo)?.admin;
+        // Check if collection is hidden
+        const hidden = admin?.hidden;
+        if (typeof hidden === 'function' && hidden({
+          user
+        })) {
+          return false;
+        }
+        // Apply baseFilter (with backwards compatibility for baseListFilter)
+        const baseFilter = admin?.baseFilter ?? admin?.baseListFilter;
+        const baseFilterResult = await baseFilter?.({
+          limit: 0,
+          page: 1,
+          req,
+          sort: 'id'
+        });
+        // If no baseFilter, return original result
+        if (!baseFilterResult) {
+          return originalResult;
+        }
+        // If original result is true, just return the baseFilter
+        if (originalResult === true) {
+          return baseFilterResult;
+        }
+        // Combine original and baseFilter results
+        return combineWhereConstraints([originalResult, baseFilterResult], 'and');
+      };
+      return relationshipField;
+    }
+    // Recursively process nested fields
+    if ('fields' in field && field.fields) {
+      return {
+        ...field,
+        fields: applyBaseFilterToFields(field.fields, config)
+      };
+    }
+    // Handle tabs
+    if (field.type === 'tabs' && 'tabs' in field) {
+      return {
+        ...field,
+        tabs: field.tabs.map(tab => ({
+          ...tab,
+          fields: applyBaseFilterToFields(tab.fields, config)
+        }))
+      };
+    }
+    // Handle blocks
+    if (field.type === 'blocks') {
+      const blocks = field.blockReferences ?? field.blocks ?? [];
+      return {
+        ...field,
+        blocks: blocks.map(block => {
+          if (typeof block === 'string') {
+            return block;
+          }
+          return {
+            ...block,
+            fields: applyBaseFilterToFields(block.fields, config)
+          };
+        })
+      };
+    }
+    return field;
+  });
+}
+//# sourceMappingURL=applyBaseFilterToFields.js.map

package/dist/utilities/applyBaseFilterToFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyBaseFilterToFields.js","names":["combineWhereConstraints","applyBaseFilterToFields","fields","config","map","field","type","relationshipField","originalFilterOptions","filterOptions","args","relationTo","req","user","originalResult","admin","collections","find","slug","hidden","baseFilter","baseListFilter","baseFilterResult","limit","page","sort","tabs","tab","blocks","blockReferences","block"],"sources":["../../src/utilities/applyBaseFilterToFields.ts"],"sourcesContent":["import type { Block, Field, SanitizedConfig, TypedUser } from '@ruya.sa/payload'\n\nimport { combineWhereConstraints } from '@ruya.sa/payload/shared'\n\n/**\n * Recursively applies baseFilter from collection config to relationship fields\n * within blocks. This ensures that relationship drawers in blocks respect\n * collection-level filters like multi-tenant filtering.\n *\n * Based on the fix from PR #13229 for LinkFeature\n */\nexport function applyBaseFilterToFields(fields: Field[], config: SanitizedConfig): Field[] {\n  return fields.map((field) => {\n    // Handle relationship fields\n    if (field.type === 'relationship') {\n      const relationshipField = field\n\n      // Store the original filterOptions\n      const originalFilterOptions = relationshipField.filterOptions\n\n      // Create new filterOptions that includes baseFilter\n      relationshipField.filterOptions = async (args) => {\n        const { relationTo, req, user } = args\n\n        // Call original filterOptions if it exists\n        const originalResult =\n          typeof originalFilterOptions === 'function'\n            ? await originalFilterOptions(args)\n            : (originalFilterOptions ?? true)\n\n        // If original filter returns false, respect that\n        if (originalResult === false) {\n          return false\n        }\n\n        // Get the collection's admin config\n        const admin = config.collections.find(({ slug }) => slug === relationTo)?.admin\n\n        // Check if collection is hidden\n        const hidden = admin?.hidden\n        if (typeof hidden === 'function' && hidden({ user } as { user: TypedUser })) {\n          return false\n        }\n\n        // Apply baseFilter (with backwards compatibility for baseListFilter)\n        const baseFilter = admin?.baseFilter ?? admin?.baseListFilter\n        const baseFilterResult = await baseFilter?.({\n          limit: 0,\n          page: 1,\n          req,\n          sort: 'id',\n        })\n\n        // If no baseFilter, return original result\n        if (!baseFilterResult) {\n          return originalResult\n        }\n\n        // If original result is true, just return the baseFilter\n        if (originalResult === true) {\n          return baseFilterResult\n        }\n\n        // Combine original and baseFilter results\n        return combineWhereConstraints([originalResult, baseFilterResult], 'and')\n      }\n\n      return relationshipField\n    }\n\n    // Recursively process nested fields\n    if ('fields' in field && field.fields) {\n      return {\n        ...field,\n        fields: applyBaseFilterToFields(field.fields, config),\n      }\n    }\n\n    // Handle tabs\n    if (field.type === 'tabs' && 'tabs' in field) {\n      return {\n        ...field,\n        tabs: field.tabs.map((tab) => ({\n          ...tab,\n          fields: applyBaseFilterToFields(tab.fields, config),\n        })),\n      }\n    }\n\n    // Handle blocks\n    if (field.type === 'blocks') {\n      const blocks = (field.blockReferences ?? field.blocks ?? []) as Block[]\n      return {\n        ...field,\n        blocks: blocks.map((block) => {\n          if (typeof block === 'string') {\n            return block\n          }\n          return {\n            ...block,\n            fields: applyBaseFilterToFields(block.fields, config),\n          }\n        }),\n      }\n    }\n\n    return field\n  })\n}\n"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ;AAExC;;;;;;;AAOA,OAAO,SAASC,wBAAwBC,MAAe,EAAEC,MAAuB;EAC9E,OAAOD,MAAA,CAAOE,GAAG,CAAEC,KAAA;IACjB;IACA,IAAIA,KAAA,CAAMC,IAAI,KAAK,gBAAgB;MACjC,MAAMC,iBAAA,GAAoBF,KAAA;MAE1B;MACA,MAAMG,qBAAA,GAAwBD,iBAAA,CAAkBE,aAAa;MAE7D;MACAF,iBAAA,CAAkBE,aAAa,GAAG,MAAOC,IAAA;QACvC,MAAM;UAAEC,UAAU;UAAEC,GAAG;UAAEC;QAAI,CAAE,GAAGH,IAAA;QAElC;QACA,MAAMI,cAAA,GACJ,OAAON,qBAAA,KAA0B,aAC7B,MAAMA,qBAAA,CAAsBE,IAAA,IAC3BF,qBAAA,IAAyB;QAEhC;QACA,IAAIM,cAAA,KAAmB,OAAO;UAC5B,OAAO;QACT;QAEA;QACA,MAAMC,KAAA,GAAQZ,MAAA,CAAOa,WAAW,CAACC,IAAI,CAAC,CAAC;UAAEC;QAAI,CAAE,KAAKA,IAAA,KAASP,UAAA,GAAaI,KAAA;QAE1E;QACA,MAAMI,MAAA,GAASJ,KAAA,EAAOI,MAAA;QACtB,IAAI,OAAOA,MAAA,KAAW,cAAcA,MAAA,CAAO;UAAEN;QAAK,IAA2B;UAC3E,OAAO;QACT;QAEA;QACA,MAAMO,UAAA,GAAaL,KAAA,EAAOK,UAAA,IAAcL,KAAA,EAAOM,cAAA;QAC/C,MAAMC,gBAAA,GAAmB,MAAMF,UAAA,GAAa;UAC1CG,KAAA,EAAO;UACPC,IAAA,EAAM;UACNZ,GAAA;UACAa,IAAA,EAAM;QACR;QAEA;QACA,IAAI,CAACH,gBAAA,EAAkB;UACrB,OAAOR,cAAA;QACT;QAEA;QACA,IAAIA,cAAA,KAAmB,MAAM;UAC3B,OAAOQ,gBAAA;QACT;QAEA;QACA,OAAOtB,uBAAA,CAAwB,CAACc,cAAA,EAAgBQ,gBAAA,CAAiB,EAAE;MACrE;MAEA,OAAOf,iBAAA;IACT;IAEA;IACA,IAAI,YAAYF,KAAA,IAASA,KAAA,CAAMH,MAAM,EAAE;MACrC,OAAO;QACL,GAAGG,KAAK;QACRH,MAAA,EAAQD,uBAAA,CAAwBI,KAAA,CAAMH,MAAM,EAAEC,MAAA;MAChD;IACF;IAEA;IACA,IAAIE,KAAA,CAAMC,IAAI,KAAK,UAAU,UAAUD,KAAA,EAAO;MAC5C,OAAO;QACL,GAAGA,KAAK;QACRqB,IAAA,EAAMrB,KAAA,CAAMqB,IAAI,CAACtB,GAAG,CAAEuB,GAAA,KAAS;UAC7B,GAAGA,GAAG;UACNzB,MAAA,EAAQD,uBAAA,CAAwB0B,GAAA,CAAIzB,MAAM,EAAEC,MAAA;QAC9C;MACF;IACF;IAEA;IACA,IAAIE,KAAA,CAAMC,IAAI,KAAK,UAAU;MAC3B,MAAMsB,MAAA,GAAUvB,KAAA,CAAMwB,eAAe,IAAIxB,KAAA,CAAMuB,MAAM,IAAI,EAAE;MAC3D,OAAO;QACL,GAAGvB,KAAK;QACRuB,MAAA,EAAQA,MAAA,CAAOxB,GAAG,CAAE0B,KAAA;UAClB,IAAI,OAAOA,KAAA,KAAU,UAAU;YAC7B,OAAOA,KAAA;UACT;UACA,OAAO;YACL,GAAGA,KAAK;YACR5B,MAAA,EAAQD,uBAAA,CAAwB6B,KAAA,CAAM5B,MAAM,EAAEC,MAAA;UAChD;QACF;MACF;IACF;IAEA,OAAOE,KAAA;EACT;AACF","ignoreList":[]}

package/dist/utilities/buildEditorState.d.ts

@@ -0,0 +1,52 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { DefaultNodeTypes, TypedEditorState } from '../nodeTypes.js';
+/**
+ * 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 declare function buildEditorState<T extends SerializedLexicalNode>({ nodes, text, }: {
+    nodes?: TypedEditorState<T>['root']['children'];
+    text?: string;
+}): TypedEditorState<T>;
+/**
+ *
+ * Alias for `buildEditorState<DefaultNodeTypes>`
+ *
+ * @experimental this API may change or be removed in a minor release
+ * @internal
+ */
+export declare const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes>;
+//# sourceMappingURL=buildEditorState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildEditorState.d.ts","sourceRoot":"","sources":["../../src/utilities/buildEditorState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAA2B,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,qBAAqB,EAAE,EAChE,KAAK,EACL,IAAI,GACL,EAAE;IACD,KAAK,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAyCtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,OAAO,gBAAgB,CAAC,gBAAgB,CAC1C,CAAA"}