@witchcraft/editor 0.0.8 → 0.1.0

package/dist/runtime/pm/generator.js

@@ -3,70 +3,63 @@ import { nanoid } from "nanoid";
 import { builders } from "prosemirror-test-builder";
 import { schema } from "./schema.js";
 export const pm = builders(schema);
-export function getTextOrMarkLength(textOrMark) {
-  if (typeof textOrMark === "string") {
-    return textOrMark.length;
-  }
-  const textNodes = textOrMark.flat.map((_) => "text" in _ ? _.text.length : getTextOrMarkLength(_));
-  return textNodes.reduce((a, b) => a + b, 0);
-}
-export function createGeneratorConfig(config) {
-  return config;
-}
-function createPsuedoSentence() {
-  const sentenceLength = faker.number.int({ min: 0, max: 1e3 });
-  const sentence = Array.from(
-    { length: sentenceLength },
-    () => faker.string.sample({ min: 0, max: 1e3 })
-  ).join(" ");
-  return sentence;
-}
+import { highlightJsLanaguages } from "./features/CodeBlock/highlightJsInfo.js";
+import { createGeneratorConfig } from "./utils/generator/createGeneratorConfig.js";
+import { createPsuedoSentence } from "./utils/generator/createPsuedoSentence.js";
+import { createRandomChildCountGenerator } from "./utils/generator/createRandomChildCountGenerator.js";
+import { sometimesZero } from "./utils/generator/sometimesZero.js";
 export const generatorConfig = [
   createGeneratorConfig({
-    isRoot: true,
     parents: { type: "node", names: ["doc"] },
-    ignoreValidation: true,
-    children: { type: "node", names: ["item"] },
-    create: (_parent, children) => {
+    children: {
+      type: "node",
+      names: [["item", 1]]
+    },
+    count: createRandomChildCountGenerator({ max: 50, zeroChance: 0 }),
+    create: (pm2, _parent, children) => {
       if (!children || children.length === 0) {
-        return pm.doc(pm.list(pm.item({ blockId: nanoid(10) }, pm.paragraph({}, ""))));
+        return pm2.doc(pm2.list(pm2.item({ blockId: nanoid(10) }, pm2.paragraph({}, ""))));
       }
-      return pm.doc(pm.list(...children));
+      return pm2.doc(pm2.list(...children));
     }
   }),
   createGeneratorConfig({
-    parents: { type: "node", names: ["list"] },
-    children: { type: "node", names: ["item"] },
-    create: (_parent, children) => {
+    parents: { type: "node", names: ["list", "doc"] },
+    children: { type: "node", names: [
+      ["item", 1]
+    ] },
+    count: createRandomChildCountGenerator({ max: 30 }),
+    create: (pm2, _parent, children) => {
       if (!children || children.length === 0) {
-        return pm.list(pm.item({ blockId: nanoid(10) }, pm.paragraph("")));
+        return pm2.list(pm2.item({ blockId: nanoid(10) }, pm2.paragraph("")));
       }
-      return pm.list(...children);
+      return pm2.list(...children);
     }
   }),
   createGeneratorConfig({
     parents: { type: "node", names: ["item"] },
     children: { type: "node", names: [
-      "paragraph",
-      "heading",
-      "codeBlock",
-      "embeddedDoc",
-      "iframe",
-      "table",
-      "image",
-      "blockquote"
+      ["paragraph", 14],
+      ["heading", 4],
+      ["codeBlock", 2],
+      ["table", 2],
+      ["image", 3],
+      ["blockquote", 4],
+      ["embeddedDoc", 1],
+      ["iframe", 1]
     ] },
-    create: (_parent, children) => {
+    count: createRandomChildCountGenerator({ max: 20, depthInfluence: 0.5 }),
+    create: (pm2, _parent, children) => {
       if (!children || children.length === 0) {
-        return pm.item({ blockId: nanoid(10) }, pm.paragraph(""));
+        return pm2.item({ blockId: nanoid(10) }, pm2.paragraph(""));
       }
-      return pm.item(
+      return pm2.item(
         { blockId: nanoid(10) },
         children[0],
-        ...children.length > 1 ? [pm.list(
+        ...children.length > 1 ? [pm2.list(
           {},
           ...children.slice(1).map(
-            (_) => pm.item({ blockId: nanoid(10) }, _)
+            (_) => pm2.item({ blockId: nanoid(10) }, _)
           )
         )] : []
       );
@@ -74,8 +67,12 @@ export const generatorConfig = [
   }),
   createGeneratorConfig({
     parents: { type: "node", names: ["blockquote"] },
-    children: { type: "node", names: ["paragraph", "cite"] },
-    create: (_parent, children) => {
+    children: { type: "node", names: [
+      ["paragraph", 1],
+      ["cite", 1]
+    ] },
+    count: () => faker.number.int({ min: 1, max: 2 }),
+    create: (pm2, _parent, children) => {
       const parTypes = [];
       const citeTypes = [];
       for (const child of children) {
@@ -86,77 +83,88 @@ export const generatorConfig = [
         }
       }
       if (parTypes.length === 0) {
-        return pm.blockquote({}, pm.paragraph(""));
+        return pm2.blockquote({}, pm2.paragraph(""));
       } else {
-        const someCite = citeTypes.find((_) => _.textContent.length > 0) ?? pm.cite({}, createPsuedoSentence());
-        return pm.blockquote({}, ...parTypes, someCite);
+        const someCite = citeTypes.find((_) => _.textContent.length > 0) ?? pm2.cite({}, createPsuedoSentence({ min: 1 }));
+        return pm2.blockquote({}, ...parTypes, someCite);
       }
     }
   }),
   createGeneratorConfig({
     parents: { type: "node", names: ["table"] },
     children: { type: "node", names: [
-      "tableHeader",
-      "tableCell"
+      ["tableCell", 1]
     ] },
-    ignoreValidation: true,
-    // we're handling the in-between tableRow nodes
-    create: (_parent, children) => {
-      const headerType = [];
-      const cellType = [];
-      for (const child of children) {
-        if (child.type.name === "tableHeader") {
-          headerType.push(child);
-        } else if (child.type.name === "tableCell") {
-          cellType.push(child);
-        }
-      }
-      const colNum = headerType.length;
-      if (colNum === 0) {
-        return pm.table({}, pm.tableRow({}, pm.tableCell(pm.paragraph(""))));
-      }
-      const rowCount = Math.ceil(cellType.length / colNum);
+    count: createRandomChildCountGenerator({ max: 50, depthInfluence: 0.5, zeroChance: 0 }),
+    create: (pm2, _parent, children) => {
+      const colNum = faker.number.int({ min: 1, max: Math.min(children.length, 10) });
+      const rowCount = Math.floor(children.length / colNum);
       const rows = [];
+      const addHeader = faker.datatype.boolean();
+      if (addHeader) {
+        const nodes = Array.from(
+          { length: colNum },
+          () => pm2.tableHeader({}, pm2.paragraph({}, createPsuedoSentence({ min: 1 })))
+        );
+        rows.push(pm2.tableRow({}, ...nodes));
+      }
       for (let i = 0; i < rowCount; i++) {
-        rows.push(pm.tableRow({}, ...cellType.slice(i * colNum, (i + 1) * colNum)));
+        const rowChildren = children.slice(i * colNum, (i + 1) * colNum);
+        if (rowChildren.length === 0) continue;
+        rows.push(pm2.tableRow({}, ...rowChildren));
       }
-      return pm.table({}, pm.tableRow({}, ...headerType), ...rows);
+      if (rows.length === 0) return void 0;
+      return pm2.table({}, ...rows);
     }
   }),
   createGeneratorConfig({
-    parents: { type: "node", names: ["tableHeader", "tableCell"] },
-    children: { type: "node", names: ["paragraph"] },
-    create: (_parent, children) => {
+    parents: { type: "node", names: ["tableCell"] },
+    children: { type: "node", names: [
+      ["paragraph", 1]
+    ] },
+    count: () => sometimesZero(1),
+    create: (pm2, _parent, children) => {
       if (!children || children.length === 0) {
-        return pm.tableCell(pm.paragraph(""));
+        return pm2.tableCell(pm2.paragraph(""));
       }
-      return pm.tableCell(...children.slice(0, 1));
+      return pm2.tableCell(...children.slice(0, 1));
     }
   }),
   createGeneratorConfig({
-    parents: { type: "node", names: ["paragraph", "heading", "codeBlock", "cite", "heading"] },
+    parents: { type: "text", names: ["paragraph", "heading", "codeBlock", "cite", "heading"] },
     children: { type: "text", names: [
-      "bold",
-      "italic",
-      "underline",
-      "strike",
-      "subscript",
-      "superscript",
-      "code",
-      "link"
+      ["bold", 1],
+      ["italic", 1],
+      ["underline", 1],
+      ["strike", 1],
+      ["subscript", 1],
+      ["superscript", 1],
+      ["code", 1],
+      ["link", 1],
+      ["text", 10]
     ] },
-    create(parent, children) {
+    count: createRandomChildCountGenerator({ max: 5, depthInfluence: 0.2 }),
+    create(pm2, parent, children) {
       if (parent === "heading") {
-        return pm[parent]({ level: 1 }, ...children);
+        return pm2[parent]({ level: faker.number.int({ min: 1, max: 6 }) }, ...children);
       }
       if (parent === "cite") {
-        return pm[parent]({}, faker.lorem.sentence());
+        return pm2[parent]({}, faker.lorem.sentence());
       }
       if (parent === "paragraph") {
         const someIndex = faker.number.int({ min: 0, max: children.length });
-        children.splice(someIndex, 0, pm.hardBreak());
+        children.splice(someIndex, 0, pm2.hardBreak());
+      }
+      if (parent === "codeBlock") {
+        const lang = faker.helpers.arrayElement([...Object.keys(highlightJsLanaguages.aliases), void 0]);
+        const lines = faker.number.int({ min: 1, max: 10 });
+        const code = Array.from(
+          { length: lines },
+          () => createPsuedoSentence()
+        ).join("\n");
+        return pm2[parent]({ language: lang }, code);
       }
-      return pm[parent]({}, ...children);
+      return pm2[parent]({}, ...children);
     }
   }),
   createGeneratorConfig({
@@ -172,33 +180,28 @@ export const generatorConfig = [
         "link"
       ]
     },
-    // note the addition of text
+    skipChild(parentType, childType, depth) {
+      if (depth > 20) return true;
+      return parentType === childType;
+    },
     children: { type: "text", names: [
-      "bold",
-      "italic",
-      "underline",
-      "strike",
-      "subscript",
-      "superscript",
-      "link",
-      "text"
+      ["bold", 1],
+      ["italic", 1],
+      ["underline", 1],
+      ["strike", 1],
+      ["subscript", 1],
+      ["superscript", 1],
+      ["link", 1],
+      ["text", 10]
     ] },
-    ignoreValidation: ["text"]
-    // text is not a real node
-    // create: (parent, children) => {
-    // 	return pm[parent]({}, ...children as any) as any
-    // }
-  }),
-  createGeneratorConfig({
-    ignoreValidation: true,
-    // text is not a real node
-    parents: { type: "text", names: ["code"] },
-    children: { type: "text", names: ["text"] }
+    count: createRandomChildCountGenerator({ max: 5, depthInfluence: 0.7 }),
+    create: (pm2, parent, children) => {
+      return pm2[parent]({}, ...children);
+    }
   }),
   createGeneratorConfig({
     parents: { type: "text", names: ["text"] },
-    children: { type: "text" },
-    create: (_parent) => {
+    create: () => {
       return createPsuedoSentence();
     }
   })

package/dist/runtime/pm/utils/generateRandomDoc.d.ts

@@ -1,23 +1,5 @@
 import type { Node } from "@tiptap/pm/model";
 import type { builders } from "prosemirror-test-builder";
-import { generateRandomTree } from "./generateRandomTree.js";
-import type { GeneratorConfigEntry } from "../generator.js";
-/**
- * Generates a random doc using faker js.
- *
- * A config describing how to create the doc is required. One is available under `pm/generator`.
- *
- * @experimental
- */
-export declare function generateRandomDoc<TBuilder extends ReturnType<typeof builders>, TData extends string>(builder: TBuilder, config?: GeneratorConfigEntry<any, any, any, any>[], treeOptions?: Parameters<typeof generateRandomTree>[1], { checkAfterNodeCreation }?: {
-    /**
-     * Checks if every returned node is valid for debugging invalid generator configs.
-     *
-     * A check is always done on the root node at the end regardless of this option.
-     *
-     * It is very slow (each check, rechecks children).
-     *
-     * @default false
-     */
-    checkAfterNodeCreation?: boolean;
-}): Node;
+import type { GeneratorConfigEntry } from "./generator/createGeneratorConfig.js";
+export declare function generateRandomDoc<TBuilder extends ReturnType<typeof builders>>(pm: TBuilder, config?: GeneratorConfigEntry<any, any, any, any>[]): Node;
+export declare function pickWeightedChild(options: [string, number][]): string | undefined;

package/dist/runtime/pm/utils/generateRandomDoc.js

@@ -1,83 +1,42 @@
-import { unreachable } from "@alanscodelog/utils/unreachable";
 import { faker } from "@faker-js/faker";
-import { generateRandomTree } from "./generateRandomTree.js";
 import { generatorConfig } from "../generator.js";
-export function generateRandomDoc(builder, config = generatorConfig, treeOptions, {
-  checkAfterNodeCreation = false
-} = {}) {
-  const schema = builder.schema;
-  const map = {};
-  function schemaFilter(name) {
-    return name !== "text" && name !== schema.topNodeType.name;
-  }
-  for (const entry of config) {
-    for (const node of entry.parents.names) {
-      if (node === "") throw new Error(`Empty node name ""`);
-      const type = entry.parents.type === "node" ? schema.nodes[node] : schema.marks[node];
-      if (type === void 0 && node !== "text") {
-        throw new Error(`${node} (on entry of type ${entry.parents.type}) not found in schema. Valid names are ${Object.keys(entry.parents.type === "node" ? schema.nodes : schema.marks)}`);
-      }
-      for (const node2 of entry.parents.names) {
-        const subEntry = { ...entry };
-        if (entry.ignoreValidation === void 0 || entry.ignoreValidation !== true) {
-          const childrenToValidate = (entry.children.names ?? []).filter((_) => !Array.isArray(entry.ignoreValidation) || !entry.ignoreValidation.includes(_));
-          for (const child of childrenToValidate) {
-            if (child === "") throw new Error(`Empty node name ""`);
-            if (entry.children.type === "node") {
-              const childType = schema.nodes[child];
-              const possibleNames = [childType.name, ...(childType.spec.group ?? "").split(" ").filter((e) => e !== "")];
-              const isAllowedChild = type.spec.content && possibleNames.some((n) => type.spec.content.includes(n));
-              if (!(isAllowedChild && schemaFilter(childType.name))) {
-                throw new Error(`Node ${node2} cannot contain child of type ${child}`);
-              }
-            } else {
-              const childType = schema.marks[child];
-              if (entry.parents.type === "node") {
-              } else {
-                const possibleNames = [childType.name, ...(childType.spec.group ?? "").split(" ").filter((e) => e !== "")];
-                const t = type;
-                const isExcluded = t.spec.excludes !== void 0 && possibleNames.some((n) => {
-                  return t.spec.excludes.includes(n) || t.spec.excludes.includes("_");
-                });
-                if (isExcluded) {
-                  throw new Error(`Mark ${node2} cannot contain mark child of type ${child}`);
-                }
-              }
-            }
-          }
-        }
-        map[node2] = { ...subEntry };
-      }
+export function generateRandomDoc(pm, config = generatorConfig) {
+  function generateNode(pm2, nodeConfig, parentType, depth = 0) {
+    if (!nodeConfig.parents.names.includes(parentType)) {
+      throw new Error(`Node config ${nodeConfig.parents.names.join(", ")} does not include parent type ${parentType}`);
     }
-  }
-  const children = generateRandomTree({
-    parentData: (data) => {
-      if (data === "") return "";
-      if (!data) unreachable();
-      if (!map[data] || !map[data].children.names || map[data].children.names.length === 0) {
-        return "";
-      } else {
-        const picked = faker.helpers.arrayElement(map[data].children.names);
-        return picked;
+    const nodes = [];
+    if ("count" in nodeConfig) {
+      const childrenCount = nodeConfig.count(depth);
+      for (let i = 0; i < childrenCount; i++) {
+        const type = pickWeightedChild(nodeConfig.children.names);
+        if (type === void 0) continue;
+        if (nodeConfig?.skipChild?.(parentType, type, depth)) continue;
+        const childConfig = config.find((c) => {
+          return c.parents.names.includes(type);
+        });
+        if (!childConfig) continue;
+        const child = generateNode(pm2, childConfig, type, depth + 1);
+        if (child === void 0) continue;
+        nodes.push(child);
       }
-    },
-    createNode: (children2, _isLeaf, data) => {
-      if (data === "") return void 0;
-      if (!data) unreachable();
-      const type = schema.nodes[data];
-      if (!type) return void 0;
-      const parent = map[data]?.create?.(data, children2) ?? builder[data]({}, ...children2);
-      if (checkAfterNodeCreation) {
-        ;
-        parent?.check?.();
-      }
-      return parent;
     }
-  }, {
-    ...treeOptions,
-    initialData: schema.topNodeType.name
-  });
-  const doc = map[schema.topNodeType.name]?.create?.(schema.topNodeType.name, children) ?? builder[schema.topNodeType.name]({}, ...children);
-  doc.check?.();
-  return doc;
+    return nodeConfig.create(pm2, parentType, nodes);
+  }
+  const firstEntry = config[0];
+  if (firstEntry === void 0) throw new Error("No config entries found.");
+  if (!("children" in firstEntry)) throw new Error("No children found in the first config entry. The first entry must have children.");
+  const startingType = pickWeightedChild(firstEntry.parents.names.map((name) => [name, 1]));
+  if (startingType === void 0) throw new Error("No starting type found.");
+  return generateNode(pm, config[0], startingType);
+}
+export function pickWeightedChild(options) {
+  const totalWeight = options.reduce((sum, [, weight]) => sum + weight, 0);
+  if (totalWeight === 0) return void 0;
+  let random = faker.number.float({ min: 0, max: totalWeight });
+  for (const [name, weight] of options) {
+    if (random < weight) return name;
+    random -= weight;
+  }
+  return options[0][0];
 }

package/dist/runtime/pm/utils/generator/createGeneratorConfig.d.ts

@@ -0,0 +1,33 @@
+import type { Mark, Node } from "@tiptap/pm/model";
+import type { builders } from "prosemirror-test-builder";
+export declare function createGeneratorConfig<TBuilder extends ReturnType<typeof builders>, TChildType extends "node" | "text", TParentType extends "node" | "text", TChildNodeType extends TChildType extends "node" ? Node : (Mark | string), TParentNodeType extends TParentType extends "node" ? Node : (Mark | string)>(config: GeneratorConfigEntry<TBuilder, TChildType, TParentType, TChildNodeType, TParentNodeType>): GeneratorConfigEntry<TBuilder, TChildType, TParentType, TChildNodeType, TParentNodeType>;
+export type GeneratorConfigEntry<TBuilder extends ReturnType<typeof builders>, TChildType extends "node" | "text" = "node" | "text", TParentType extends "node" | "text" = "node" | "text", TChildNodeType extends TChildType extends "node" ? Node : (Mark | string) = TChildType extends "node" ? Node : (Mark | string), TParentNodeType extends TParentType extends "node" ? Node : (Mark | string) = TParentType extends "node" ? Node : (Mark | string)> = {
+    /**
+     * Creates the node. Can return undefined to "terminate" the branch being created, the node will be filtered out of the nodes passed to it's parent.
+     *
+     * Note also, it is not required to use the children. You can ignore them or use a subset or create different ones if needed (some node types *require* text and if count returns 0 children will be empty, which can cause issues).
+     */
+    create: (pm: TBuilder, parentType: string, children: TChildNodeType[]) => TParentNodeType | undefined;
+    parents: {
+        /**
+         * The type of the parent (node or "text") where "text" is a string or mark.
+         * Determines the call signature of the create function.
+         */
+        type: TParentType;
+        /** Possible parent nodes that can have the given children. The children need not be direct descendants or real prosemirror nodes since `create` is what determines how they're created. */
+        names: string[];
+    };
+} & ({} | {
+    skipChild?: (parentType: string, childType: string, depth: number) => boolean;
+    children: {
+        /** The type of children (node or "text") where "text" is a string or mark. */
+        type: TChildType;
+        names: [name: string, weight: number][];
+    };
+    /**
+     * How many children to generate, is passed the depth so you can make the tree "slimmer" as it does deeper.
+     *
+     * See the `sometimesZero`, `influenceWithDepth` and `createRandomChildCountGenerator` helpers to make this easier to control.
+     */
+    count: (depth: number) => number;
+});

package/dist/runtime/pm/utils/generator/createGeneratorConfig.js

@@ -0,0 +1,3 @@
+export function createGeneratorConfig(config) {
+  return config;
+}

package/dist/runtime/pm/utils/generator/createPsuedoSentence.d.ts

@@ -0,0 +1,4 @@
+export declare function createPsuedoSentence({ min, max }?: {
+    min?: number;
+    max?: number;
+}): string;

package/dist/runtime/pm/utils/generator/createPsuedoSentence.js

@@ -0,0 +1,16 @@
+import { faker } from "@faker-js/faker";
+export function createPsuedoSentence({ min = 0, max = 10 } = {}) {
+  const sentenceLength = faker.number.int({ min, max });
+  const sentence = Array.from(
+    { length: sentenceLength },
+    () => {
+      const doLorem = faker.number.float() < 0.5;
+      if (doLorem) {
+        return faker.lorem.word();
+      } else {
+        return faker.string.sample({ min: 1, max: 10 });
+      }
+    }
+  ).join(" ");
+  return sentence;
+}

package/dist/runtime/pm/utils/generator/createRandomChildCountGenerator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Combines `sometimesZero` and `influenceWithDepth` to create a function that returns a random number to pass to `count`.
+ *
+ * ```ts
+ * count: createRandomChildCountGenerator({ max: 10, depthInfluence: 0.5 })
+ * // or
+ * count: (depth: number) => createRandomChildCountGenerator({ max: 10, depthInfluence: 0.5 })(depth)
+ * ```
+ */
+export declare function createRandomChildCountGenerator({ max, zeroChance, depthInfluence }: {
+    max: number;
+    zeroChance?: number;
+    depthInfluence?: number;
+}): (depth: number) => number;

package/dist/runtime/pm/utils/generator/createRandomChildCountGenerator.js

@@ -0,0 +1,16 @@
+import { faker } from "@faker-js/faker";
+import { influenceWithDepth } from "./influenceWithDepth.js";
+import { sometimesZero } from "./sometimesZero.js";
+export function createRandomChildCountGenerator({
+  max = 10,
+  zeroChance = 0.05,
+  depthInfluence = 1
+}) {
+  return (depth) => {
+    depth++;
+    return sometimesZero(
+      faker.number.int({ min: 1, max: influenceWithDepth(max, depth, depthInfluence) || 1 }),
+      zeroChance
+    );
+  };
+}

package/dist/runtime/pm/utils/generator/getTextOrMarkLength.d.ts

@@ -0,0 +1,2 @@
+import type { Mark } from "@tiptap/pm/model";
+export declare function getTextOrMarkLength(textOrMark: string | Mark): number;

package/dist/runtime/pm/utils/generator/getTextOrMarkLength.js

@@ -0,0 +1,7 @@
+export function getTextOrMarkLength(textOrMark) {
+  if (typeof textOrMark === "string") {
+    return textOrMark.length;
+  }
+  const textNodes = textOrMark.flat.map((_) => "text" in _ ? _.text.length : getTextOrMarkLength(_));
+  return textNodes.reduce((a, b) => a + b, 0);
+}

package/dist/runtime/pm/utils/generator/influenceWithDepth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Decreases the given number by dividing it by the depth + 1 (so it it's not zero). Returns a floored *int*.
+ *
+ * Intended to help decrease the number of nodes as the depth increases. Can be adjusted by the strength parameter, to, for example, decrease the adjustment for nodes that tend to be deeper.
+ */
+export declare function influenceWithDepth(num: number, depth: number, strength?: number): number;

package/dist/runtime/pm/utils/generator/influenceWithDepth.js

@@ -0,0 +1,6 @@
+export function influenceWithDepth(num, depth, strength = 1) {
+  if (num === 0) return 0;
+  depth++;
+  const adjusted = Math.floor(num / (depth * strength));
+  return adjusted;
+}

package/dist/runtime/pm/utils/generator/sometimesZero.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns 0 instead of the given number depending on the chance passed (0.05 by default).
+ *
+ * This is useful to avoid too many empty nodes without having to increase the max a lot.
+ *
+ * You can pass chance 0 to always return the given number.
+ */
+export declare function sometimesZero(num: number, chance?: number, getRandom?: (options?: number | {
+    min?: number;
+    max?: number;
+    fractionDigits?: number;
+    multipleOf?: number;
+}) => number): number;

package/dist/runtime/pm/utils/generator/sometimesZero.js

@@ -0,0 +1,7 @@
+import { faker } from "@faker-js/faker";
+export function sometimesZero(num, chance = 0.05, getRandom = faker.number.float) {
+  if (getRandom() < chance) {
+    return 0;
+  }
+  return num;
+}