unist-plugin-log-tree 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ipikuka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,392 @@
+**A robust Next.js newsletter `Next.js Weekly` is sponsoring me** 💖
+[![NextjsWeekly banner](./assets/next-js-weekly.png)](https://nextjsweekly.com/)
+
+### [Become a sponsor](https://github.com/sponsors/ipikuka) 🚀
+
+If you find **`unist-plugin-log-tree`** useful in your projects, consider supporting my work.  
+Your sponsorship means a lot 💖
+
+My sponsors are going to be featured here and on [my sponsor wall](https://github.com/sponsors/ipikuka).
+
+A warm thanks 🙌 to [@ErfanEbrahimnia](https://github.com/ErfanEbrahimnia), [@recepkyk](https://github.com/recepkyk), and [@LSeaburg](https://github.com/LSeaburg) for the support!
+
+Thank you for supporting open source! 🙌
+
+# unist-plugin-log-tree
+
+[![npm version][badge-npm-version]][url-npm-package]
+[![npm downloads][badge-npm-download]][url-npm-package]
+[![publish to npm][badge-publish-to-npm]][url-publish-github-actions]
+[![code-coverage][badge-codecov]][url-codecov]
+[![type-coverage][badge-type-coverage]][url-github-package]
+[![typescript][badge-typescript]][url-typescript]
+[![license][badge-license]][url-license]
+
+This package is a [**unified**][unified] ([**remark**][remark]) plugin **to log and optionally filter unist syntax trees for debugging purposes.** It is debugging plugin for the unified ecosystem that logs unist syntax trees without transforming.
+
+[**unified**][unified] is a project that transforms content with abstract syntax trees (ASTs) using the new parser [**micromark**][micromark]. [**remark**][remark] adds support for markdown to unified. [**mdast**][mdast] is the Markdown Abstract Syntax Tree (AST) which is a specification for representing markdown in a syntax tree. **[rehype][rehype]** is a tool that transforms HTML with plugins. **[hast][hast]** stands for HTML Abstract Syntax Tree (HAST) that rehype uses. **[recma][recma]** adds support for producing a javascript code by transforming **[esast][esast]** which stands for Ecma Script Abstract Syntax Tree (AST) that is used in production of compiled source for the **[MDX][MDX]**.
+
+**This plugin is a universal syntax tree (unist) plugin for mdast, hast, estree, and other unist-based trees. It does not transform the tree; it only inspects and logs it for debugging.**
+
+# unist-plugin-log-tree
+
+A debugging plugin for the unified ecosystem that logs unist syntax trees without transforming them.
+
+## When should I use this?
+
+**`unist-plugin-log-tree`** is useful when you want to **inspect, debug, or snapshot syntax trees** during a unified processing pipeline.
+
+It works with any unist-compatible tree:
+
+- mdast (remark)
+- hast (rehype)
+- estree / recma
+- any custom unist-based AST
+
+This plugin:
+
+- ✅ Logs the syntax tree to the console
+- ✅ Optionally filters nodes using `test`
+- ✅ Preserves parent chains when filtering
+- ✅ Optionally preserves full subtrees
+- ✅ Can hide `position` data
+- ❌ Does **not** transform or mutate the original tree
+
+It is purely a debugging utility.
+
+## Installation
+
+This package is ESM only.
+
+In Node.js (version 16+), install with npm:
+
+```bash
+npm install unist-plugin-log-tree
+```
+
+or
+
+```bash
+yarn add unist-plugin-log-tree
+```
+
+## Usage
+
+### ⚠️ Important: Factory Pattern Usage
+
+This plugin follows a **factory pattern**.
+
+Unlike typical unified plugins that are used like this:
+
+```js
+.use(plugin, options)
+```
+
+this plugin **must be used like this**:
+
+```js
+.use(plugin(options))
+```
+
+### Why?
+
+The plugin is implemented as a factory so that it can be used multiple times in a single unified pipeline — for example, to log different stages (mdast, hast, etc.) independently.
+
+Because of this structure, it returns a configured plugin instance immediately, which is why `.use(plugin(options))` is required.
+
+### Basic usage (log full tree)
+
+```js
+import { read } from "to-vfile";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import logTree from "unist-plugin-log-tree";
+
+const file = await unified()
+  .use(remarkParse)
+  .use(logTree()) // ← factory call
+  .process(await read("example.md"));
+```
+
+Running this will print the full mdast to the console.
+
+### With filtering
+
+You can pass a `test` option (powered by `unist-util-is`) to log only specific nodes.
+
+```js
+.use(logTree({ test: "heading" }))
+```
+
+This will:
+
+- Keep only `heading` nodes
+- Preserve their parent chain
+- Remove unrelated branches
+
+### With label
+
+```js
+.use(logTree({ label: "Remark AST" }))
+```
+
+Console output:
+
+```
+[unist-log-tree] Remark AST
+{ ...tree }
+```
+
+### In a full pipeline (remark → rehype)
+
+```js
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import rehypeStringify from "rehype-stringify";
+import logTree from "unist-plugin-log-tree";
+
+await unified()
+  .use(remarkParse)
+  .use(logTree({ label: "MDAST" }))
+  .use(remarkRehype)
+  .use(logTree({ label: "HAST" }))
+  .use(rehypeStringify)
+  .process("# Hello");
+```
+
+This logs both the mdast and hast trees.
+
+## Options
+
+All options are optional.
+
+```ts
+type UnistLogTreeOptions = {
+  test?: Test;
+  preserveSubtree?: boolean;
+  preservePositions?: boolean;
+  depth?: number | null;
+  indentation?: number;
+  label?: string;
+  enabled?: boolean;
+};
+```
+
+### `test`
+
+Type: `Test` (from `unist-util-is`)  
+Default: `undefined`
+
+Filters the tree. Only matching nodes and their parent chain are kept.
+
+Examples:
+
+```js
+test: "heading"
+test: ["heading", "paragraph"]
+test: (node) => node.type === "link"
+```
+
+If `test` is `undefined` or `null`, the full tree is logged.
+
+### `preserveSubtree`
+
+Type: `boolean`  
+Default: `true`
+
+Controls behavior when a node matches `test`.
+
+- `true` → Keep the entire subtree of the matched node.
+- `false` → Recursively filter its children as well.
+
+Example:
+
+```js
+.use(logTree({
+  test: "heading",
+  preserveSubtree: false
+}))
+```
+
+### `preservePositions`
+
+Type: `boolean`  
+Default: `false`
+
+Controls whether `position` data is included in the output.
+
+```js
+.use(logTree({ preservePositions: true }))
+```
+
+### `depth`
+
+Type: `number | null`  
+Default: `null`
+
+Passed to `console.dir` as the `depth` option.
+
+```js
+.use(logTree({ depth: 4 }))
+```
+
+### `indentation`
+
+Type: `number`  
+Default: `2`
+
+Controls JSON indentation size before printing.
+
+### `label`
+
+Type: `string`  
+Default: `undefined`
+
+Adds a label before the logged tree.
+
+```js
+.use(logTree({ label: "Rehype AST" }))
+```
+
+### `enabled`
+
+Type: `boolean`  
+Default: `true`
+
+Allows turning the logger off without removing it from the pipeline.
+
+```js
+.use(logTree({ enabled: false }))
+```
+
+Useful in CI or production builds.
+
+## Filtering Behavior
+
+When `test` is provided:
+
+- Matching nodes are kept.
+- Parent nodes are preserved if any descendant matches.
+- Non-matching branches are removed.
+- The original AST is never mutated.
+
+The plugin internally clones the tree before pruning.
+
+## Syntax Tree
+
+This plugin does **not** transform the syntax tree. It:
+
+- Clones the tree (when filtering)
+- Optionally prunes branches
+- Logs the result
+- Leaves the original AST untouched
+
+## Types
+
+This package is fully typed with TypeScript. The options type is exported as:
+
+```ts
+UnistLogTreeOptions
+```
+
+## Compatibility
+
+This plugin works with unified version `6+`, and any unist-compatible trees in a plugin chain of remark, rehype, recma.
+
+## Security
+
+This plugin does not generate HTML, execute user code, or manipulate output content. It only logs syntax trees to the console. There are no XSS or runtime security concerns.
+
+## My Plugins
+
+I like to contribute the Unified / Remark / MDX ecosystem, so I recommend you to have a look my plugins.
+
+### My Remark Plugins
+
+- [`remark-flexible-code-titles`](https://www.npmjs.com/package/remark-flexible-code-titles)
+  – Remark plugin to add titles or/and containers for the code blocks with customizable properties
+- [`remark-flexible-containers`](https://www.npmjs.com/package/remark-flexible-containers)
+  – Remark plugin to add custom containers with customizable properties in markdown
+- [`remark-ins`](https://www.npmjs.com/package/remark-ins)
+  – Remark plugin to add `ins` element in markdown
+- [`remark-flexible-paragraphs`](https://www.npmjs.com/package/remark-flexible-paragraphs)
+  – Remark plugin to add custom paragraphs with customizable properties in markdown
+- [`remark-flexible-markers`](https://www.npmjs.com/package/remark-flexible-markers)
+  – Remark plugin to add custom `mark` element with customizable properties in markdown
+- [`remark-flexible-toc`](https://www.npmjs.com/package/remark-flexible-toc)
+  – Remark plugin to expose the table of contents via `vfile.data` or via an option reference
+- [`remark-mdx-remove-esm`](https://www.npmjs.com/package/remark-mdx-remove-esm)
+  – Remark plugin to remove import and/or export statements (mdxjsEsm)
+- [`remark-mdx-remove-expressions`](https://www.npmjs.com/package/remark-mdx-remove-expressions)
+  – Remark plugin to remove MDX expressions within curlybraces {} in MDX content
+
+### My Rehype Plugins
+
+- [`rehype-pre-language`](https://www.npmjs.com/package/rehype-pre-language)
+  – Rehype plugin to add language information as a property to `pre` element
+- [`rehype-highlight-code-lines`](https://www.npmjs.com/package/rehype-highlight-code-lines)
+  – Rehype plugin to add line numbers to code blocks and allow highlighting of desired code lines
+- [`rehype-code-meta`](https://www.npmjs.com/package/rehype-code-meta)
+  – Rehype plugin to copy `code.data.meta` to `code.properties.metastring`
+- [`rehype-image-toolkit`](https://www.npmjs.com/package/rehype-image-toolkit)
+  – Rehype plugin to enhance Markdown image syntax `![]()` and Markdown/MDX media elements (`<img>`, `<audio>`, `<video>`) by auto-linking bracketed or parenthesized image URLs, wrapping them in `<figure>` with optional captions, unwrapping images/videos/audio from paragraph, parsing directives in title for styling and adding attributes, and dynamically converting images into `<video>` or `<audio>` elements based on file extension.
+
+### My Recma Plugins
+
+- [`recma-mdx-escape-missing-components`](https://www.npmjs.com/package/recma-mdx-escape-missing-components)
+  – Recma plugin to set the default value `() => null` for the Components in MDX in case of missing or not provided so as not to throw an error
+- [`recma-mdx-change-props`](https://www.npmjs.com/package/recma-mdx-change-props)
+  – Recma plugin to change the `props` parameter into the `_props` in the `function _createMdxContent(props) {/* */}` in the compiled source in order to be able to use `{props.foo}` like expressions. It is useful for the `next-mdx-remote` or `next-mdx-remote-client` users in `nextjs` applications.
+- [`recma-mdx-change-imports`](https://www.npmjs.com/package/recma-mdx-change-imports)
+  – Recma plugin to convert import declarations for assets and media with relative links into variable declarations with string URLs, enabling direct asset URL resolution in compiled MDX.
+- [`recma-mdx-import-media`](https://www.npmjs.com/package/recma-mdx-import-media)
+  – Recma plugin to turn media relative paths into import declarations for both markdown and html syntax in MDX.
+- [`recma-mdx-import-react`](https://www.npmjs.com/package/recma-mdx-import-react)
+  – Recma plugin to ensure getting `React` instance from the arguments and to make the runtime props `{React, jsx, jsxs, jsxDev, Fragment}` is available in the dynamically imported components in the compiled source of MDX.
+- [`recma-mdx-html-override`](https://www.npmjs.com/package/recma-mdx-html-override)
+  – Recma plugin to allow selected raw HTML elements to be overridden via MDX components.
+- [`recma-mdx-interpolate`](https://www.npmjs.com/package/recma-mdx-interpolate)
+  – Recma plugin to enable interpolation of identifiers wrapped in curly braces within the `alt`, `src`, `href`, and `title` attributes of markdown link and image syntax in MDX.
+
+### My Unist Utils and Plugins
+
+I also build low-level utilities and plugins for the Unist ecosystem that can be used across Remark, Rehype, Recma, and other syntax trees.
+
+- [`unist-util-find-between-all`](https://www.npmjs.com/package/unist-util-find-between-all)
+  – Unist utility to find the nodes between two nodes.
+- [`unist-plugin-log-tree`](https://www.npmjs.com/package/unist-plugin-log-tree)
+  – Debugging plugin for the unified ecosystem that logs abstract syntax trees (ASTs) without transforming.
+
+## License
+
+[MIT License](./LICENSE) © ipikuka
+
+[unified]: https://github.com/unifiedjs/unified
+[micromark]: https://github.com/micromark/micromark
+[remark]: https://github.com/remarkjs/remark
+[mdast]: https://github.com/syntax-tree/mdast
+[rehype]: https://github.com/rehypejs/rehype
+[hast]: https://github.com/syntax-tree/hast
+[recma]: https://mdxjs.com/docs/extending-mdx/#list-of-plugins
+[esast]: https://github.com/syntax-tree/esast
+[MDX]: https://mdxjs.com/
+
+[badge-npm-version]: https://img.shields.io/npm/v/unist-plugin-log-tree
+[badge-npm-download]:https://img.shields.io/npm/dt/unist-plugin-log-tree
+[url-npm-package]: https://www.npmjs.com/package/unist-plugin-log-tree
+[url-github-package]: https://github.com/ipikuka/unist-plugin-log-tree
+
+[badge-license]: https://img.shields.io/github/license/ipikuka/unist-plugin-log-tree
+[url-license]: https://github.com/ipikuka/unist-plugin-log-tree/blob/main/LICENSE
+
+[badge-publish-to-npm]: https://github.com/ipikuka/unist-plugin-log-tree/actions/workflows/publish.yml/badge.svg
+[url-publish-github-actions]: https://github.com/ipikuka/unist-plugin-log-tree/actions/workflows/publish.yml
+
+[badge-typescript]: https://img.shields.io/npm/types/unist-plugin-log-tree
+[url-typescript]: https://www.typescriptlang.org/
+
+[badge-codecov]: https://codecov.io/gh/ipikuka/unist-plugin-log-tree/graph/badge.svg?token=bzXcCBzY4P
+[url-codecov]: https://codecov.io/gh/ipikuka/unist-plugin-log-tree
+
+[badge-type-coverage]: https://img.shields.io/badge/dynamic/json.svg?label=type-coverage&prefix=%E2%89%A5&suffix=%&query=$.typeCoverage.atLeast&uri=https%3A%2F%2Fraw.githubusercontent.com%2Fipikuka%2Funist-plugin-log-tree%2Fmaster%2Fpackage.json
+

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from "unified";
+import type { Node as UnistNode } from "unist";
+import type { Test } from "unist-util-is";
+export interface Node extends UnistNode {
+    [key: string]: unknown;
+}
+export type UnistLogTreeOptions = {
+    depth?: number | null;
+    indentation?: number;
+    preservePositions?: boolean;
+    test?: Test;
+    preserveSubtree?: boolean;
+    label?: string;
+    enabled?: boolean;
+};
+/**
+ * Debug utility plugin for unified processors.
+ *
+ * Logs the current unist tree (mdast, hast, estree, etc.)
+ * with optional filtering and formatting controls.
+ *
+ * If `test` is provided, only matching nodes and their
+ * parent chain are preserved in the output.
+ *
+ * The original tree is never mutated.
+ */
+export default function plugin(options?: UnistLogTreeOptions): Plugin<[], Node>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAO1C,MAAM,WAAW,IAAK,SAAQ,SAAS;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAmBF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAqJ9E"}

package/dist/index.js

@@ -0,0 +1,140 @@
+import { is } from "unist-util-is";
+const DEFAULT_SETTINGS = {
+    depth: null,
+    indentation: 2,
+    preservePositions: false,
+    test: undefined,
+    preserveSubtree: true,
+    label: undefined,
+    enabled: true,
+};
+/**
+ * Debug utility plugin for unified processors.
+ *
+ * Logs the current unist tree (mdast, hast, estree, etc.)
+ * with optional filtering and formatting controls.
+ *
+ * If `test` is provided, only matching nodes and their
+ * parent chain are preserved in the output.
+ *
+ * The original tree is never mutated.
+ */
+export default function plugin(options) {
+    return function attacher() {
+        const settings = Object.assign({}, DEFAULT_SETTINGS, options);
+        // early exit
+        if (!settings.enabled) {
+            return function transformer(tree) {
+                return tree;
+            };
+        }
+        /*
+         * Type guard to check if an array of Node
+         */
+        function isNodeArray(value) {
+            return (Array.isArray(value) &&
+                value.every((item) => item && typeof item === "object" && "type" in item));
+        }
+        /*
+         * Type guard to check if a node is a unist Node
+         */
+        function isNode(value) {
+            return !!value && typeof value === "object" && "type" in value;
+        }
+        /**
+         * Builds a minimal subtree that keeps only nodes matching the test and their parent chain.
+         * It uses prune algoritm that works on children key, so with mdast and hast okey but with esast doesn't work
+         */
+        // function buildFilteredTreeEx(root: Node, test: Test): Node {
+        //   const cloned = structuredClone(root);
+        //   function prune(node: Node): boolean {
+        //     const matched = is(node, test);
+        //     if (isParent(node)) {
+        //       if (matched && settings.preserveSubtree !== false) {
+        //         return true; // don't touch subtree
+        //       }
+        //       node.children = node.children.filter((child) => prune(child));
+        //     }
+        //     if (matched) return true;
+        //     if (isParent(node)) {
+        //       return node.children.length > 0;
+        //     }
+        //     return false;
+        //   }
+        //   const keepRoot = prune(cloned);
+        //   if (!keepRoot && isParent(cloned)) {
+        //     cloned.children = [];
+        //   }
+        //   return cloned;
+        // }
+        /**
+         * Builds a minimal subtree that keeps only nodes matching the test and their parent chain.
+         * It is a universal travel algoritim works with any AST like mdast, hast, esast and others
+         */
+        function buildFilteredTree(root, test) {
+            const cloned = structuredClone(root);
+            function prune(node) {
+                const matched = is(node, test);
+                let hasChildMatch = false;
+                for (const key in node) {
+                    if (key === "position")
+                        continue;
+                    const value = node[key];
+                    if (!value)
+                        continue;
+                    if (isNodeArray(value)) {
+                        let containsNode = false;
+                        for (let i = value.length - 1; i >= 0; i--) {
+                            const item = value[i];
+                            /* v8 ignore next -- @preserve */
+                            if (isNode(item)) {
+                                containsNode = true;
+                                const keep = prune(item);
+                                if (!keep) {
+                                    value.splice(i, 1);
+                                }
+                                else {
+                                    hasChildMatch = true;
+                                }
+                            }
+                        }
+                        if (containsNode && value.length === 0) {
+                            node[key] = [];
+                        }
+                    }
+                    else if (isNode(value)) {
+                        const keep = prune(value);
+                        if (!keep) {
+                            delete node[key];
+                        }
+                        else {
+                            hasChildMatch = true;
+                        }
+                    }
+                }
+                if (matched && settings.preserveSubtree !== false) {
+                    return true; // don't touch subtree
+                }
+                if (matched)
+                    return true;
+                return hasChildMatch;
+            }
+            prune(cloned);
+            return cloned;
+        }
+        return function transformer(tree) {
+            const targetTree = settings.test != null ? buildFilteredTree(tree, settings.test) : tree;
+            if (settings.label) {
+                console.log(`[unist-log-tree] ${settings.label}`);
+            }
+            const output = JSON.parse(JSON.stringify(targetTree, (key, value) => {
+                if (!settings.preservePositions && key === "position") {
+                    return undefined;
+                }
+                return value;
+            }));
+            console.dir(output, { depth: settings.depth });
+        };
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Plugin } from \"unified\";\nimport type { Node as UnistNode } from \"unist\";\nimport type { Test } from \"unist-util-is\";\nimport { is } from \"unist-util-is\";\n\ntype Prettify<T> = { [K in keyof T]: T[K] } & {};\n\ntype PartiallyRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;\n\nexport interface Node extends UnistNode {\n  [key: string]: unknown;\n}\n\nexport type UnistLogTreeOptions = {\n  depth?: number | null;\n  indentation?: number;\n  preservePositions?: boolean;\n  test?: Test;\n  preserveSubtree?: boolean;\n  label?: string;\n  enabled?: boolean;\n};\n\nconst DEFAULT_SETTINGS: UnistLogTreeOptions = {\n  depth: null,\n  indentation: 2,\n  preservePositions: false,\n  test: undefined,\n  preserveSubtree: true,\n  label: undefined,\n  enabled: true,\n};\n\ntype PartiallyRequiredOptions = Prettify<\n  PartiallyRequired<\n    UnistLogTreeOptions,\n    \"depth\" | \"indentation\" | \"preservePositions\" | \"enabled\"\n  >\n>;\n\n/**\n * Debug utility plugin for unified processors.\n *\n * Logs the current unist tree (mdast, hast, estree, etc.)\n * with optional filtering and formatting controls.\n *\n * If `test` is provided, only matching nodes and their\n * parent chain are preserved in the output.\n *\n * The original tree is never mutated.\n */\nexport default function plugin(options?: UnistLogTreeOptions): Plugin<[], Node> {\n  return function attacher() {\n    const settings = Object.assign({}, DEFAULT_SETTINGS, options) as PartiallyRequiredOptions;\n\n    // early exit\n    if (!settings.enabled) {\n      return function transformer(tree: Node) {\n        return tree;\n      };\n    }\n\n    /*\n     * Type guard to check if an array of Node\n     */\n    function isNodeArray(value: unknown): value is Node[] {\n      return (\n        Array.isArray(value) &&\n        (value as unknown[]).every((item) => item && typeof item === \"object\" && \"type\" in item)\n      );\n    }\n\n    /*\n     * Type guard to check if a node is a unist Node\n     */\n    function isNode(value: unknown): value is Node {\n      return !!value && typeof value === \"object\" && \"type\" in value;\n    }\n\n    /**\n     * Builds a minimal subtree that keeps only nodes matching the test and their parent chain.\n     * It uses prune algoritm that works on children key, so with mdast and hast okey but with esast doesn't work\n     */\n    // function buildFilteredTreeEx(root: Node, test: Test): Node {\n    //   const cloned = structuredClone(root);\n\n    //   function prune(node: Node): boolean {\n    //     const matched = is(node, test);\n\n    //     if (isParent(node)) {\n    //       if (matched && settings.preserveSubtree !== false) {\n    //         return true; // don't touch subtree\n    //       }\n\n    //       node.children = node.children.filter((child) => prune(child));\n    //     }\n\n    //     if (matched) return true;\n\n    //     if (isParent(node)) {\n    //       return node.children.length > 0;\n    //     }\n\n    //     return false;\n    //   }\n\n    //   const keepRoot = prune(cloned);\n\n    //   if (!keepRoot && isParent(cloned)) {\n    //     cloned.children = [];\n    //   }\n\n    //   return cloned;\n    // }\n\n    /**\n     * Builds a minimal subtree that keeps only nodes matching the test and their parent chain.\n     * It is a universal travel algoritim works with any AST like mdast, hast, esast and others\n     */\n    function buildFilteredTree(root: Node, test: Test): Node {\n      const cloned = structuredClone(root);\n\n      function prune(node: Node): boolean {\n        const matched = is(node, test);\n\n        let hasChildMatch = false;\n\n        for (const key in node) {\n          if (key === \"position\") continue;\n\n          const value = node[key];\n\n          if (!value) continue;\n\n          if (isNodeArray(value)) {\n            let containsNode = false;\n\n            for (let i = value.length - 1; i >= 0; i--) {\n              const item = value[i];\n\n              /* v8 ignore next -- @preserve */\n              if (isNode(item)) {\n                containsNode = true;\n\n                const keep = prune(item);\n\n                if (!keep) {\n                  value.splice(i, 1);\n                } else {\n                  hasChildMatch = true;\n                }\n              }\n            }\n\n            if (containsNode && value.length === 0) {\n              node[key] = [];\n            }\n          } else if (isNode(value)) {\n            const keep = prune(value);\n\n            if (!keep) {\n              delete node[key];\n            } else {\n              hasChildMatch = true;\n            }\n          }\n        }\n\n        if (matched && settings.preserveSubtree !== false) {\n          return true; // don't touch subtree\n        }\n\n        if (matched) return true;\n\n        return hasChildMatch;\n      }\n\n      prune(cloned);\n      return cloned;\n    }\n\n    return function transformer(tree: Node) {\n      const targetTree = settings.test != null ? buildFilteredTree(tree, settings.test) : tree;\n\n      if (settings.label) {\n        console.log(`[unist-log-tree] ${settings.label}`);\n      }\n\n      const output: Node = JSON.parse(\n        JSON.stringify(targetTree, (key: string, value: unknown) => {\n          if (!settings.preservePositions && key === \"position\") {\n            return undefined;\n          }\n          return value;\n        }),\n      );\n\n      console.dir(output, { depth: settings.depth });\n    };\n  };\n}\n"]}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "unist-plugin-log-tree",
+  "version": "1.0.1",
+  "description": "A debugging plugin for the unified ecosystem that logs unist syntax trees without transforming.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc --build && type-coverage",
+    "format": "npm run prettier && npm run lint",
+    "prettier": "prettier --write .",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:file": "vitest test.plugin.spec.ts",
+    "test-coverage": "vitest run --coverage",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run format && npm run test-coverage"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ipikuka/unist-plugin-log-tree.git"
+  },
+  "keywords": [
+    "unified",
+    "mdast",
+    "markdown",
+    "MDX",
+    "remark",
+    "plugin",
+    "remark plugin",
+    "remark marker",
+    "remark markers",
+    "remark flexible markers"
+  ],
+  "author": "ipikuka <talatkuyuk@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/ipikuka/unist-plugin-log-tree#readme",
+  "bugs": {
+    "url": "https://github.com/ipikuka/unist-plugin-log-tree/issues"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.10.13",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/eslint-plugin": "^1.6.9",
+    "dedent": "^1.7.1",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.3",
+    "type-coverage": "^2.29.7",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0",
+    "unified": "^11.0.5",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@types/mdast": "^4.0.4",
+    "unist-builder": "^4.0.0",
+    "unist-util-find-after": "^5.0.0",
+    "unist-util-find-all-after": "^5.0.0",
+    "unist-util-find-all-before": "^5.0.0",
+    "unist-util-find-between-all": "^1.1.6",
+    "unist-util-visit": "^5.1.0"
+  },
+  "peerDependencies": {
+    "unified": "^11"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreAsAssertion": true,
+    "ignoreCatch": true,
+    "strict": true
+  }
+}