@prismicio/richtext - npm Package Compare versions

Comparing version 2.1.1 to 2.1.2

dist/index.d.ts

@@ -1,130 +0,7 @@
-import { RichTextNodeType, RTAnyNode, RTHeading1Node, RTHeading2Node, RTHeading3Node, RTHeading4Node, RTHeading5Node, RTHeading6Node, RTParagraphNode, RTPreformattedNode, RTStrongNode, RTEmNode, RTListItemNode, RTOListItemNode, RTListNode, RTOListNode, RTImageNode, RTEmbedNode, RTLinkNode, RTLabelNode, RTSpanNode, RTNode, RichTextField } from '@prismicio/types';
-export { RichTextNodeType as Element } from '@prismicio/types';
-
-/**
- * Serializes a node from a rich text or title field with a function
- *
- * @typeParam ReturnType - Return type of the function serializer
- * @see Templating rich text and title fields from Prismic {@link https://prismic.io/docs/technologies/templating-rich-text-and-title-fields-javascript}
- */
-declare type RichTextFunctionSerializer<ReturnType> = (type: typeof RichTextNodeType[keyof typeof RichTextNodeType], node: RTAnyNode, text: string | undefined, children: ReturnType[], key: string) => ReturnType | null | undefined;
-/**
- * Map serializer's tag function serializer, can be helpful for typing those handlers
- *
- * @typeParam ReturnType - Return type of the tag serializer
- */
-declare type RichTextMapSerializerFunction<ReturnType, Node extends RTAnyNode = RTAnyNode, TextType = string | undefined> = (payload: {
-    type: Node["type"];
-    node: Node;
-    text: TextType;
-    children: ReturnType[];
-    key: string;
-}) => ReturnType | null | undefined;
-/**
- * Serializes a node from a rich text or title field with a map
- *
- * @remarks
- * This type of serializer needs to be processed through
- * {@link wrapMapSerializer} before being used with {@link serialize}
- * @typeParam ReturnType - Return type of the map serializer
- * @see Templating rich text and title fields from Prismic {@link https://prismic.io/docs/technologies/templating-rich-text-and-title-fields-javascript}
- */
-declare type RichTextMapSerializer<ReturnType> = {
-    heading1?: RichTextMapSerializerFunction<ReturnType, RTHeading1Node, undefined>;
-    heading2?: RichTextMapSerializerFunction<ReturnType, RTHeading2Node, undefined>;
-    heading3?: RichTextMapSerializerFunction<ReturnType, RTHeading3Node, undefined>;
-    heading4?: RichTextMapSerializerFunction<ReturnType, RTHeading4Node, undefined>;
-    heading5?: RichTextMapSerializerFunction<ReturnType, RTHeading5Node, undefined>;
-    heading6?: RichTextMapSerializerFunction<ReturnType, RTHeading6Node, undefined>;
-    paragraph?: RichTextMapSerializerFunction<ReturnType, RTParagraphNode, undefined>;
-    preformatted?: RichTextMapSerializerFunction<ReturnType, RTPreformattedNode, undefined>;
-    strong?: RichTextMapSerializerFunction<ReturnType, RTStrongNode, string>;
-    em?: RichTextMapSerializerFunction<ReturnType, RTEmNode, string>;
-    listItem?: RichTextMapSerializerFunction<ReturnType, RTListItemNode, undefined>;
-    oListItem?: RichTextMapSerializerFunction<ReturnType, RTOListItemNode, undefined>;
-    list?: RichTextMapSerializerFunction<ReturnType, RTListNode, undefined>;
-    oList?: RichTextMapSerializerFunction<ReturnType, RTOListNode, undefined>;
-    image?: RichTextMapSerializerFunction<ReturnType, RTImageNode, undefined>;
-    embed?: RichTextMapSerializerFunction<ReturnType, RTEmbedNode, undefined>;
-    hyperlink?: RichTextMapSerializerFunction<ReturnType, RTLinkNode, string>;
-    label?: RichTextMapSerializerFunction<ReturnType, RTLabelNode, string>;
-    span?: RichTextMapSerializerFunction<ReturnType, RTSpanNode, string>;
-};
-interface Tree {
-    key: string;
-    children: TreeNode[];
-}
-interface TreeNode {
-    key: string;
-    type: typeof RichTextNodeType[keyof typeof RichTextNodeType];
-    text?: string;
-    node: RTAnyNode;
-    children: TreeNode[];
-}
-
-/**
- * Parses a rich text or title field into a tree
- *
- * @remarks
- * This is a low level helper mainly intended to be used by higher level
- * packages. Most users aren't expected to this function directly.
- * @param nodes - A rich text or title field from Prismic
- *
- * @returns Tree from given rich text or title field
- */
-declare const asTree: (nodes: RTNode[]) => Tree;
-
-/**
- * Serializes a rich text or title field to a plain text string
- *
- * @param richTextField - A rich text or title field from Prismic
- * @param separator - Separator used to join each element, defaults to a space
- *
- * @returns Plain text equivalent of the provided rich text or title field
- * @see Templating rich text and title fields from Prismic {@link https://prismic.io/docs/technologies/templating-rich-text-and-title-fields-javascript}
- */
-declare const asText: (richTextField: RichTextField, separator?: string) => string;
-
-/**
- * Serializes a rich text or title field with a given serializer
- *
- * @remarks
- * This is a low level helper mainly intended to be used by higher level
- * packages Most users aren't expected to this function directly
- * @typeParam SerializerReturnType - Return type of the serializer
- * @param richTextField - A rich text or title field from Prismic
- * @param serializer - A function serializer to apply
- *
- * @returns An array of serialized nodes
- * @see Templating rich text and title fields from Prismic {@link https://prismic.io/docs/technologies/templating-rich-text-and-title-fields-javascript}
- */
-declare const serialize: <SerializerReturnType>(richTextField: RichTextField, serializer: RichTextFunctionSerializer<SerializerReturnType>) => SerializerReturnType[];
-
-/**
- * Wraps a map serializer into a regular function serializer
- *
- * @remarks
- * This is a low level helper mainly intended to be used by higher level
- * packages Most users aren't expected to this function directly
- * @typeParam SerializerReturnType - Return type of the map serializer
- * @param mapSerializer - Map serializer to wrap
- *
- * @returns A regular function serializer
- */
-declare const wrapMapSerializer: <SerializerReturnType>(mapSerializer: RichTextMapSerializer<SerializerReturnType>) => RichTextFunctionSerializer<SerializerReturnType>;
-
-/**
- * Takes an array of serializers and returns a serializer applying provided
- * serializers sequentially until a result is returned
- *
- * @remarks
- * This is a low level helper mainly intended to be used by higher level
- * packages Most users aren't expected to this function directly
- * @typeParam SerializerReturnType - Return type of serializers
- * @param serializers - Serializers to compose
- *
- * @returns Composed serializer
- */
-declare const composeSerializers: <SerializerReturnType>(...serializers: (RichTextFunctionSerializer<SerializerReturnType> | undefined)[]) => RichTextFunctionSerializer<SerializerReturnType>;
-
-export { RichTextFunctionSerializer, RichTextMapSerializer, RichTextMapSerializerFunction, asText, asTree, composeSerializers, serialize, wrapMapSerializer };
+export { asTree } from "./asTree";
+export { asText } from "./asText";
+export { serialize } from "./serialize";
+export { wrapMapSerializer } from "./wrapMapSerializer";
+export { composeSerializers } from "./composeSerializers";
+export { RichTextNodeType as Element } from "@prismicio/types";
+export type { RichTextFunctionSerializer, RichTextMapSerializer, RichTextMapSerializerFunction, } from "./types";

dist/index.js

@@ -1,202 +0,15 @@
-import { RichTextNodeType } from '@prismicio/types';
-export { RichTextNodeType as Element } from '@prismicio/types';
-
-const uuid = () => {
-  return (++uuid.i).toString();
+import { asTree } from "./asTree.js";
+import { asText } from "./asText.js";
+import { serialize } from "./serialize.js";
+import { wrapMapSerializer } from "./wrapMapSerializer.js";
+import { composeSerializers } from "./composeSerializers.js";
+import { RichTextNodeType } from "@prismicio/types";
+export {
+  RichTextNodeType as Element,
+  asText,
+  asTree,
+  composeSerializers,
+  serialize,
+  wrapMapSerializer
 };
-uuid.i = 0;
-const asTree = (nodes) => {
-  const preparedNodes = prepareNodes(nodes);
-  const children = [];
-  for (let i = 0; i < preparedNodes.length; i++) {
-    children.push(nodeToTreeNode(preparedNodes[i]));
-  }
-  return {
-    key: uuid(),
-    children
-  };
-};
-const createTreeNode = (node, children = []) => {
-  return {
-    key: uuid(),
-    type: node.type,
-    text: "text" in node ? node.text : void 0,
-    node,
-    children
-  };
-};
-const createTextTreeNode = (text) => {
-  return createTreeNode({
-    type: RichTextNodeType.span,
-    text,
-    spans: []
-  });
-};
-const prepareNodes = (nodes) => {
-  const mutNodes = nodes.slice(0);
-  for (let i = 0; i < mutNodes.length; i++) {
-    const node = mutNodes[i];
-    if (node.type === RichTextNodeType.listItem || node.type === RichTextNodeType.oListItem) {
-      const items = [
-        node
-      ];
-      while (mutNodes[i + 1] && mutNodes[i + 1].type === node.type) {
-        items.push(mutNodes[i + 1]);
-        mutNodes.splice(i, 1);
-      }
-      if (node.type === RichTextNodeType.listItem) {
-        mutNodes[i] = {
-          type: RichTextNodeType.list,
-          items
-        };
-      } else {
-        mutNodes[i] = {
-          type: RichTextNodeType.oList,
-          items
-        };
-      }
-    }
-  }
-  return mutNodes;
-};
-const nodeToTreeNode = (node) => {
-  if ("text" in node) {
-    return createTreeNode(
-      node,
-      textNodeSpansToTreeNodeChildren(node.spans, node)
-    );
-  }
-  if ("items" in node) {
-    const children = [];
-    for (let i = 0; i < node.items.length; i++) {
-      children.push(nodeToTreeNode(node.items[i]));
-    }
-    return createTreeNode(node, children);
-  }
-  return createTreeNode(node);
-};
-const textNodeSpansToTreeNodeChildren = (spans, node, parentSpan) => {
-  if (!spans.length) {
-    return [createTextTreeNode(node.text)];
-  }
-  const mutSpans = spans.slice(0);
-  mutSpans.sort((a, b) => a.start - b.start || b.end - a.end);
-  const children = [];
-  for (let i = 0; i < mutSpans.length; i++) {
-    const span = mutSpans[i];
-    const parentSpanStart = parentSpan && parentSpan.start || 0;
-    const spanStart = span.start - parentSpanStart;
-    const spanEnd = span.end - parentSpanStart;
-    const text = node.text.slice(spanStart, spanEnd);
-    const childSpans = [];
-    for (let j = i; j < mutSpans.length; j++) {
-      const siblingSpan = mutSpans[j];
-      if (siblingSpan !== span && siblingSpan.start >= span.start && siblingSpan.end <= span.end) {
-        childSpans.push(siblingSpan);
-        mutSpans.splice(j, 1);
-        j--;
-      }
-    }
-    if (i === 0 && spanStart > 0) {
-      children.push(createTextTreeNode(node.text.slice(0, spanStart)));
-    }
-    const spanWithText = { ...span, text };
-    children.push(
-      createTreeNode(
-        spanWithText,
-        textNodeSpansToTreeNodeChildren(
-          childSpans,
-          {
-            ...node,
-            text
-          },
-          span
-        )
-      )
-    );
-    if (spanEnd < node.text.length) {
-      children.push(
-        createTextTreeNode(
-          node.text.slice(
-            spanEnd,
-            mutSpans[i + 1] ? mutSpans[i + 1].start - parentSpanStart : void 0
-          )
-        )
-      );
-    }
-  }
-  return children;
-};
-
-const asText = (richTextField, separator = " ") => {
-  let result = "";
-  for (let i = 0; i < richTextField.length; i++) {
-    if ("text" in richTextField[i]) {
-      result += (result ? separator : "") + richTextField[i].text;
-    }
-  }
-  return result;
-};
-
-const serialize = (richTextField, serializer) => {
-  return serializeTreeNodes(
-    asTree(richTextField).children,
-    serializer
-  );
-};
-const serializeTreeNodes = (nodes, serializer) => {
-  const serializedTreeNodes = [];
-  for (let i = 0; i < nodes.length; i++) {
-    const treeNode = nodes[i];
-    const serializedTreeNode = serializer(
-      treeNode.type,
-      treeNode.node,
-      treeNode.text,
-      serializeTreeNodes(treeNode.children, serializer),
-      treeNode.key
-    );
-    if (serializedTreeNode != null) {
-      serializedTreeNodes.push(serializedTreeNode);
-    }
-  }
-  return serializedTreeNodes;
-};
-
-const RichTextReversedNodeType = {
-  [RichTextNodeType.listItem]: "listItem",
-  [RichTextNodeType.oListItem]: "oListItem",
-  [RichTextNodeType.list]: "list",
-  [RichTextNodeType.oList]: "oList"
-};
-
-const wrapMapSerializer = (mapSerializer) => {
-  return (type, node, text, children, key) => {
-    const tagSerializer = mapSerializer[RichTextReversedNodeType[type] || type];
-    if (tagSerializer) {
-      return tagSerializer({
-        type,
-        node,
-        text,
-        children,
-        key
-      });
-    }
-  };
-};
-
-const composeSerializers = (...serializers) => {
-  return (...args) => {
-    for (let i = 0; i < serializers.length; i++) {
-      const serializer = serializers[i];
-      if (serializer) {
-        const res = serializer(...args);
-        if (res != null) {
-          return res;
-        }
-      }
-    }
-  };
-};
-
-export { asText, asTree, composeSerializers, serialize, wrapMapSerializer };
 //# sourceMappingURL=index.js.map

package.json

 {
 	"name": "@prismicio/richtext",
-	"version": "2.1.1",
+	"version": "2.1.2",
 	"description": "A parser and serializer for Prismic's Rich Text format",
@@ -33,4 +33,4 @@ "keywords": [
 	"scripts": {
-		"build": "siroc build",
-		"dev": "siroc build --watch",
+		"build": "vite build",
+		"dev": "vite build --watch",
 		"format": "prettier --write .",
@@ -49,20 +49,21 @@ "lint": "eslint --ext .js,.ts .",
 	"dependencies": {
-		"@prismicio/types": "^0.2.0"
+		"@prismicio/types": "^0.2.5"
 	},
 	"devDependencies": {
-		"@size-limit/preset-small-lib": "^7.0.8",
-		"@typescript-eslint/eslint-plugin": "^5.31.0",
-		"@typescript-eslint/parser": "^5.31.0",
-		"c8": "^7.12.0",
-		"eslint": "^8.20.0",
+		"@size-limit/preset-small-lib": "^8.1.0",
+		"@typescript-eslint/eslint-plugin": "^5.46.1",
+		"@typescript-eslint/parser": "^5.46.1",
+		"@vitest/coverage-c8": "^0.26.0",
+		"eslint": "^8.30.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-prettier": "^4.2.1",
-		"eslint-plugin-tsdoc": "^0.2.16",
-		"prettier": "^2.7.1",
-		"prettier-plugin-jsdoc": "^0.3.38",
-		"siroc": "^0.16.0",
-		"size-limit": "^7.0.8",
+		"eslint-plugin-tsdoc": "^0.2.17",
+		"prettier": "^2.8.1",
+		"prettier-plugin-jsdoc": "^0.4.2",
+		"size-limit": "^8.1.0",
 		"standard-version": "^9.5.0",
-		"typescript": "^4.7.4",
-		"vitest": "^0.19.1"
+		"typescript": "^4.9.4",
+		"vite": "^4.0.2",
+		"vite-plugin-sdk": "^0.1.0",
+		"vitest": "^0.26.0"
 	},
@@ -69,0 +70,0 @@ "engines": {

src/types.ts

@@ -42,3 +42,4 @@ import {
 /**
- * Map serializer's tag function serializer, can be helpful for typing those handlers
+ * Map serializer's tag function serializer, can be helpful for typing those
+ * handlers
  *
@@ -45,0 +46,0 @@ * @typeParam ReturnType - Return type of the tag serializer

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Number of package files

45

increased by200%

Lines of code

1026

increased by3.64%

Worsened metrics

Total package byte prevSize

88798

decreased by-1.44%

Dev dependency count

16

increased by6.67%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updated@prismicio/types@^0.2.5