@datocms/cma-client 5.1.1 → 5.1.2

package/dist/esm/utilities/structuredText.js

@@ -1,354 +0,0 @@
-/**
- * Tree manipulation utilities for DatoCMS structured text documents.
- *
- * Provides a set of low-level utilities for visiting, transforming, and querying
- * structured text trees. Works with all tree variants (regular, request, nested).
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/**
- * Check if a value has children property that is an array
- */
-function hasChildren(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'children' in node &&
-        Array.isArray(node.children));
-}
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Synchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- */
-export function forEachNode(node, visitor, parent = null, path = []) {
-    // Visit current node
-    visitor(node, parent, path);
-    // Recursively visit children
-    if (hasChildren(node)) {
-        for (let index = 0; index < node.children.length; index++) {
-            const child = node.children[index];
-            forEachNode(child, visitor, node, [
-                ...path,
-                'children',
-                index,
-            ]);
-        }
-    }
-}
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Asynchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- * @returns Promise that resolves when all nodes have been visited
- */
-export function forEachNodeAsync(node, visitor, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Visit current node
-        yield visitor(node, parent, path);
-        // Recursively visit children
-        if (hasChildren(node)) {
-            for (let index = 0; index < node.children.length; index++) {
-                const child = node.children[index];
-                yield forEachNodeAsync(child, visitor, node, [
-                    ...path,
-                    'children',
-                    index,
-                ]);
-            }
-        }
-    });
-}
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Synchronous function that transforms each node. Receives the node, its parent, and path
- * @returns The transformed tree
- */
-export function mapNodes(node, mapper, parent = null, path = []) {
-    // Transform current node
-    const transformedNode = mapper(node, parent, path);
-    // If the original node has children, recursively transform them
-    if (hasChildren(node) &&
-        typeof transformedNode === 'object' &&
-        transformedNode !== null) {
-        const transformedChildren = node.children.map((child, index) => mapNodes(child, mapper, node, [
-            ...path,
-            'children',
-            index,
-        ]));
-        return Object.assign(Object.assign({}, transformedNode), { children: transformedChildren });
-    }
-    return transformedNode;
-}
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Asynchronous function that transforms each node. Receives the node, its parent, and path
- * @returns Promise that resolves to the transformed tree
- */
-export function mapNodesAsync(node, mapper, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Transform current node
-        const transformedNode = yield mapper(node, parent, path);
-        // If the original node has children, recursively transform them
-        if (hasChildren(node) &&
-            typeof transformedNode === 'object' &&
-            transformedNode !== null) {
-            const transformedChildren = yield Promise.all(node.children.map((child, index) => mapNodesAsync(child, mapper, node, [
-                ...path,
-                'children',
-                index,
-            ])));
-            return Object.assign(Object.assign({}, transformedNode), { children: transformedChildren });
-        }
-        return transformedNode;
-    });
-}
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for desired nodes
- * @returns Array of objects, each containing a matching node and its path
- */
-export function findAllNodes(node, predicate, parent = null, path = []) {
-    const results = [];
-    forEachNode(node, (currentNode, currentParent, currentPath) => {
-        if (predicate(currentNode, currentParent, currentPath)) {
-            results.push({ node: currentNode, path: currentPath });
-        }
-    }, parent, path);
-    return results;
-}
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for desired nodes
- * @returns Promise that resolves to an array of objects, each containing a matching node and its path
- */
-export function findAllNodesAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const results = [];
-        yield forEachNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            if (yield predicate(currentNode, currentParent, currentPath)) {
-                results.push({ node: currentNode, path: currentPath });
-            }
-        }), parent, path);
-        return results;
-    });
-}
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Synchronous function that tests each node. Nodes returning false are removed
- * @returns The filtered tree, or null if root node is filtered out
- */
-export function filterNodes(node, predicate, parent = null, path = []) {
-    // If current node doesn't match predicate, return null
-    if (!predicate(node, parent, path)) {
-        return null;
-    }
-    // If node has no children, return it as-is
-    if (!hasChildren(node)) {
-        return node;
-    }
-    // Filter children recursively
-    const childrenResults = node.children.map((child, index) => filterNodes(child, predicate, node, [
-        ...path,
-        'children',
-        index,
-    ]));
-    const filteredChildren = childrenResults.filter((child) => child !== null);
-    return Object.assign(Object.assign({}, node), { children: filteredChildren });
-}
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Asynchronous function that tests each node. Nodes returning false are removed
- * @returns Promise that resolves to the filtered tree, or null if root node is filtered out
- */
-export function filterNodesAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // If current node doesn't match predicate, return null
-        if (!(yield predicate(node, parent, path))) {
-            return null;
-        }
-        // If node has no children, return it as-is
-        if (!hasChildren(node)) {
-            return node;
-        }
-        // Filter children recursively
-        const childrenResults = yield Promise.all(node.children.map((child, index) => filterNodesAsync(child, predicate, node, [
-            ...path,
-            'children',
-            index,
-        ])));
-        const filteredChildren = childrenResults.filter((child) => child !== null);
-        return Object.assign(Object.assign({}, node), { children: filteredChildren });
-    });
-}
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Synchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns The final accumulated value
- */
-export function reduceNodes(node, reducer, initialValue, parent = null, path = []) {
-    let accumulator = initialValue;
-    forEachNode(node, (currentNode, currentParent, currentPath) => {
-        accumulator = reducer(accumulator, currentNode, currentParent, currentPath);
-    }, parent, path);
-    return accumulator;
-}
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Asynchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns Promise that resolves to the final accumulated value
- */
-export function reduceNodesAsync(node, reducer, initialValue, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let accumulator = initialValue;
-        yield forEachNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            accumulator = yield reducer(accumulator, currentNode, currentParent, currentPath);
-        }), parent, path);
-        return accumulator;
-    });
-}
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for matching nodes
- * @returns True if any node matches, false otherwise
- */
-export function someNode(node, predicate, parent = null, path = []) {
-    // Check current node
-    if (predicate(node, parent, path)) {
-        return true;
-    }
-    // Recursively check children
-    if (hasChildren(node)) {
-        for (let index = 0; index < node.children.length; index++) {
-            const child = node.children[index];
-            if (someNode(child, predicate, node, [
-                ...path,
-                'children',
-                index,
-            ])) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for matching nodes
- * @returns Promise that resolves to true if any node matches, false otherwise
- */
-export function someNodeAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Check current node
-        if (yield predicate(node, parent, path)) {
-            return true;
-        }
-        // Recursively check children
-        if (hasChildren(node)) {
-            for (let index = 0; index < node.children.length; index++) {
-                const child = node.children[index];
-                if (yield someNodeAsync(child, predicate, node, [
-                    ...path,
-                    'children',
-                    index,
-                ])) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    });
-}
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Synchronous function that tests each node. Should return true for valid nodes
- * @returns True if all nodes match, false otherwise
- */
-export function everyNode(node, predicate, parent = null, path = []) {
-    return !someNode(node, (currentNode, currentParent, currentPath) => {
-        return !predicate(currentNode, currentParent, currentPath);
-    }, parent, path);
-}
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Asynchronous function that tests each node. Should return true for valid nodes
- * @returns Promise that resolves to true if all nodes match, false otherwise
- */
-export function everyNodeAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return !(yield someNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            return !(yield predicate(currentNode, currentParent, currentPath));
-        }), parent, path));
-    });
-}
-//# sourceMappingURL=structuredText.js.map

package/dist/esm/utilities/structuredText.js.map

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

package/dist/types/utilities/structuredText.d.ts

@@ -1,177 +0,0 @@
-/**
- * Tree manipulation utilities for DatoCMS structured text documents.
- *
- * Provides a set of low-level utilities for visiting, transforming, and querying
- * structured text trees. Works with all tree variants (regular, request, nested).
- */
-/**
- * Recursively extract all possible node types that can appear in a tree structure
- */
-type AllNodesInTree<T, Depth extends number = 10> = Depth extends 0 ? T extends readonly unknown[] ? never : T : T extends readonly (infer U)[] ? AllNodesInTree<U, Prev<Depth>> : T extends {
-    children: infer Children;
-} ? T | AllNodesInTree<Children, Prev<Depth>> : T;
-type Prev<T extends number> = T extends 0 ? 0 : T extends 1 ? 0 : T extends 2 ? 1 : T extends 3 ? 2 : T extends 4 ? 3 : T extends 5 ? 4 : T extends 6 ? 5 : T extends 7 ? 6 : T extends 8 ? 7 : T extends 9 ? 8 : T extends 10 ? 9 : number;
-/**
- * Path through the Structured Text tree structure
- */
-export type TreePath = readonly (string | number)[];
-/**
- * Generic predicate function type for Structured Text tree node filtering
- */
-export type NodePredicate<T, R> = (node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => R;
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Synchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- */
-export declare function forEachNode<T>(node: T, visitor: NodePredicate<T, void>, parent?: AllNodesInTree<T> | null, path?: TreePath): void;
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Asynchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- * @returns Promise that resolves when all nodes have been visited
- */
-export declare function forEachNodeAsync<T>(node: T, visitor: NodePredicate<T, Promise<void>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<void>;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Synchronous function that transforms each node. Receives the node, its parent, and path
- * @returns The transformed tree
- */
-export declare function mapNodes<T, R>(node: T, mapper: NodePredicate<T, R>, parent?: AllNodesInTree<T> | null, path?: TreePath): R;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Asynchronous function that transforms each node. Receives the node, its parent, and path
- * @returns Promise that resolves to the transformed tree
- */
-export declare function mapNodesAsync<T, R>(node: T, mapper: NodePredicate<T, Promise<R>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<R>;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for desired nodes
- * @returns Array of objects, each containing a matching node and its path
- */
-export declare function findAllNodes<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): Array<{
-    node: AllNodesInTree<T>;
-    path: TreePath;
-}>;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for desired nodes
- * @returns Promise that resolves to an array of objects, each containing a matching node and its path
- */
-export declare function findAllNodesAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<Array<{
-    node: AllNodesInTree<T>;
-    path: TreePath;
-}>>;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Synchronous function that tests each node. Nodes returning false are removed
- * @returns The filtered tree, or null if root node is filtered out
- */
-export declare function filterNodes<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): T | null;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Asynchronous function that tests each node. Nodes returning false are removed
- * @returns Promise that resolves to the filtered tree, or null if root node is filtered out
- */
-export declare function filterNodesAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<T | null>;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Synchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns The final accumulated value
- */
-export declare function reduceNodes<T, R>(node: T, reducer: (accumulator: R, node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => R, initialValue: R, parent?: AllNodesInTree<T> | null, path?: TreePath): R;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Asynchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns Promise that resolves to the final accumulated value
- */
-export declare function reduceNodesAsync<T, R>(node: T, reducer: (accumulator: R, node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => Promise<R>, initialValue: R, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<R>;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for matching nodes
- * @returns True if any node matches, false otherwise
- */
-export declare function someNode<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): boolean;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for matching nodes
- * @returns Promise that resolves to true if any node matches, false otherwise
- */
-export declare function someNodeAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<boolean>;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Synchronous function that tests each node. Should return true for valid nodes
- * @returns True if all nodes match, false otherwise
- */
-export declare function everyNode<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): boolean;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Asynchronous function that tests each node. Should return true for valid nodes
- * @returns Promise that resolves to true if all nodes match, false otherwise
- */
-export declare function everyNodeAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<boolean>;
-export {};