@rushstack/lookup-by-path 0.8.16 → 0.9.1

package/CHANGELOG.json

@@ -1,6 +1,40 @@
 {
   "name": "@rushstack/lookup-by-path",
   "entries": [
+    {
+      "version": "0.9.1",
+      "tag": "@rushstack/lookup-by-path_v0.9.1",
+      "date": "Fri, 20 Feb 2026 00:15:04 GMT",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Add `\"node\"` condition before `\"import\"` in the `\"exports\"` map so that Node.js uses the CJS output (which handles extensionless imports), while bundlers still use ESM via `\"import\"`. Fixes https://github.com/microsoft/rushstack/issues/5644."
+          }
+        ],
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@rushstack/heft\" to `1.2.1`"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.9.0",
+      "tag": "@rushstack/lookup-by-path_v0.9.0",
+      "date": "Thu, 19 Feb 2026 00:04:53 GMT",
+      "comments": {
+        "minor": [
+          {
+            "comment": "Normalize package layout. CommonJS is now under `lib-commonjs`, DTS is now under `lib-dts`, and ESM is now under `lib-esm`. Imports to `lib` still work as before, handled by the `\"exports\"` field in `package.json`."
+          }
+        ],
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@rushstack/heft\" to `1.2.0`"
+          }
+        ]
+      }
+    },
     {
       "version": "0.8.16",
       "tag": "@rushstack/lookup-by-path_v0.8.16",

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Change Log - @rushstack/lookup-by-path
 
-This log was last generated on Sat, 07 Feb 2026 01:13:26 GMT and should not be manually modified.
+This log was last generated on Fri, 20 Feb 2026 00:15:04 GMT and should not be manually modified.
+
+## 0.9.1
+Fri, 20 Feb 2026 00:15:04 GMT
+
+### Patches
+
+- Add `"node"` condition before `"import"` in the `"exports"` map so that Node.js uses the CJS output (which handles extensionless imports), while bundlers still use ESM via `"import"`. Fixes https://github.com/microsoft/rushstack/issues/5644.
+
+## 0.9.0
+Thu, 19 Feb 2026 00:04:53 GMT
+
+### Minor changes
+
+- Normalize package layout. CommonJS is now under `lib-commonjs`, DTS is now under `lib-dts`, and ESM is now under `lib-esm`. Imports to `lib` still work as before, handled by the `"exports"` field in `package.json`.
 
 ## 0.8.16
 Sat, 07 Feb 2026 01:13:26 GMT

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.56.2"
+      "packageVersion": "7.57.0"
     }
   ]
 }

package/lib-esm/LookupByPath.js

@@ -0,0 +1,351 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/**
+ * This class is used to associate path-like-strings, such as those returned by `git` commands,
+ * with entities that correspond with ancestor folders, such as Rush Projects or npm packages.
+ *
+ * It is optimized for efficiently locating the nearest ancestor path with an associated value.
+ *
+ * It is implemented as a Trie (https://en.wikipedia.org/wiki/Trie) data structure, with each edge
+ * being a path segment.
+ *
+ * @example
+ * ```ts
+ * const trie = new LookupByPath([['foo', 1], ['bar', 2], ['foo/bar', 3]]);
+ * trie.findChildPath('foo'); // returns 1
+ * trie.findChildPath('foo/baz'); // returns 1
+ * trie.findChildPath('baz'); // returns undefined
+ * trie.findChildPath('foo/bar/baz'); returns 3
+ * trie.findChildPath('bar/foo/bar'); returns 2
+ * ```
+ * @beta
+ */
+export class LookupByPath {
+    /**
+     * Constructs a new `LookupByPath`
+     *
+     * @param entries - Initial path-value pairs to populate the trie.
+     */
+    constructor(entries, delimiter) {
+        this._root = {
+            value: undefined,
+            children: undefined
+        };
+        this.delimiter = delimiter !== null && delimiter !== void 0 ? delimiter : '/';
+        this._size = 0;
+        if (entries) {
+            for (const [path, item] of entries) {
+                this.setItem(path, item);
+            }
+        }
+    }
+    /**
+     * Iterates over the segments of a serialized path.
+     *
+     * @example
+     *
+     * `LookupByPath.iteratePathSegments('foo/bar/baz')` yields 'foo', 'bar', 'baz'
+     *
+     * `LookupByPath.iteratePathSegments('foo\\bar\\baz', '\\')` yields 'foo', 'bar', 'baz'
+     */
+    static *iteratePathSegments(serializedPath, delimiter = '/') {
+        for (const prefixMatch of this._iteratePrefixes(serializedPath, delimiter)) {
+            yield prefixMatch.prefix;
+        }
+    }
+    static *_iteratePrefixes(input, delimiter = '/') {
+        if (!input) {
+            return;
+        }
+        let previousIndex = 0;
+        let nextIndex = input.indexOf(delimiter);
+        // Leading segments
+        while (nextIndex >= 0) {
+            yield {
+                prefix: input.slice(previousIndex, nextIndex),
+                index: nextIndex
+            };
+            previousIndex = nextIndex + 1;
+            nextIndex = input.indexOf(delimiter, previousIndex);
+        }
+        // Last segment
+        if (previousIndex < input.length) {
+            yield {
+                prefix: input.slice(previousIndex, input.length),
+                index: input.length
+            };
+        }
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath.size}
+     */
+    get size() {
+        return this._size;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath.tree}
+     */
+    get tree() {
+        return this._root;
+    }
+    /**
+     * Deletes all entries from this `LookupByPath` instance.
+     *
+     * @returns this, for chained calls
+     */
+    clear() {
+        this._root.value = undefined;
+        this._root.children = undefined;
+        this._size = 0;
+        return this;
+    }
+    /**
+     * Associates the value with the specified serialized path.
+     * If a value is already associated, will overwrite.
+     *
+     * @returns this, for chained calls
+     */
+    setItem(serializedPath, value, delimiter = this.delimiter) {
+        return this.setItemFromSegments(LookupByPath.iteratePathSegments(serializedPath, delimiter), value);
+    }
+    /**
+     * Deletes an item if it exists.
+     * @param query - The path to the item to delete
+     * @param delimeter - Optional override delimeter for parsing the query
+     * @returns `true` if the item was found and deleted, `false` otherwise
+     * @remarks
+     * If the node has children with values, they will be retained.
+     */
+    deleteItem(query, delimeter = this.delimiter) {
+        const node = this._findNodeAtPrefix(query, delimeter);
+        if ((node === null || node === void 0 ? void 0 : node.value) !== undefined) {
+            node.value = undefined;
+            this._size--;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Deletes an item and all its children.
+     * @param query - The path to the item to delete
+     * @param delimeter - Optional override delimeter for parsing the query
+     * @returns `true` if any nodes were deleted, `false` otherwise
+     */
+    deleteSubtree(query, delimeter = this.delimiter) {
+        const queryNode = this._findNodeAtPrefix(query, delimeter);
+        if (!queryNode) {
+            return false;
+        }
+        const queue = [queryNode];
+        let removed = 0;
+        while (queue.length > 0) {
+            const node = queue.pop();
+            if (node.value !== undefined) {
+                node.value = undefined;
+                removed++;
+            }
+            if (node.children) {
+                for (const child of node.children.values()) {
+                    queue.push(child);
+                }
+                node.children.clear();
+            }
+        }
+        this._size -= removed;
+        return removed > 0;
+    }
+    /**
+     * Associates the value with the specified path.
+     * If a value is already associated, will overwrite.
+     *
+     * @returns this, for chained calls
+     */
+    setItemFromSegments(pathSegments, value) {
+        let node = this._root;
+        for (const segment of pathSegments) {
+            if (!node.children) {
+                node.children = new Map();
+            }
+            let child = node.children.get(segment);
+            if (!child) {
+                node.children.set(segment, (child = {
+                    value: undefined,
+                    children: undefined
+                }));
+            }
+            node = child;
+        }
+        if (node.value === undefined) {
+            this._size++;
+        }
+        node.value = value;
+        return this;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    findChildPath(childPath, delimiter = this.delimiter) {
+        return this.findChildPathFromSegments(LookupByPath.iteratePathSegments(childPath, delimiter));
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    findLongestPrefixMatch(query, delimiter = this.delimiter) {
+        return this._findLongestPrefixMatch(LookupByPath._iteratePrefixes(query, delimiter));
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    findChildPathFromSegments(childPathSegments) {
+        var _a;
+        let node = this._root;
+        let best = node.value;
+        // Trivial cases
+        if (node.children) {
+            for (const segment of childPathSegments) {
+                const child = node.children.get(segment);
+                if (!child) {
+                    break;
+                }
+                node = child;
+                best = (_a = node.value) !== null && _a !== void 0 ? _a : best;
+                if (!node.children) {
+                    break;
+                }
+            }
+        }
+        return best;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    has(key, delimiter = this.delimiter) {
+        const match = this.findLongestPrefixMatch(key, delimiter);
+        return (match === null || match === void 0 ? void 0 : match.index) === key.length;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    get(key, delimiter = this.delimiter) {
+        const match = this.findLongestPrefixMatch(key, delimiter);
+        return (match === null || match === void 0 ? void 0 : match.index) === key.length ? match.value : undefined;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    groupByChild(infoByPath, delimiter = this.delimiter) {
+        const groupedInfoByChild = new Map();
+        for (const [path, info] of infoByPath) {
+            const child = this.findChildPath(path, delimiter);
+            if (child === undefined) {
+                continue;
+            }
+            let groupedInfo = groupedInfoByChild.get(child);
+            if (!groupedInfo) {
+                groupedInfo = new Map();
+                groupedInfoByChild.set(child, groupedInfo);
+            }
+            groupedInfo.set(path, info);
+        }
+        return groupedInfoByChild;
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    *entries(query, delimiter = this.delimiter) {
+        let root;
+        if (query) {
+            root = this._findNodeAtPrefix(query, delimiter);
+            if (!root) {
+                return;
+            }
+        }
+        else {
+            root = this._root;
+        }
+        const stack = [[query !== null && query !== void 0 ? query : '', root]];
+        while (stack.length > 0) {
+            const [prefix, node] = stack.pop();
+            if (node.value !== undefined) {
+                yield [prefix, node.value];
+            }
+            if (node.children) {
+                for (const [segment, child] of node.children) {
+                    stack.push([prefix ? `${prefix}${delimiter}${segment}` : segment, child]);
+                }
+            }
+        }
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    [Symbol.iterator](query, delimiter = this.delimiter) {
+        return this.entries(query, delimiter);
+    }
+    /**
+     * {@inheritdoc IReadonlyLookupByPath}
+     */
+    getNodeAtPrefix(query, delimiter = this.delimiter) {
+        return this._findNodeAtPrefix(query, delimiter);
+    }
+    /**
+     * Iterates through progressively longer prefixes of a given string and returns as soon
+     * as the number of candidate items that match the prefix are 1 or 0.
+     *
+     * If a match is present, returns the matched itme and the length of the matched prefix.
+     *
+     * @returns the found item, or `undefined` if no item was found
+     */
+    _findLongestPrefixMatch(prefixes) {
+        let node = this._root;
+        let best = node.value
+            ? {
+                value: node.value,
+                index: 0,
+                lastMatch: undefined
+            }
+            : undefined;
+        // Trivial cases
+        if (node.children) {
+            for (const { prefix: hash, index } of prefixes) {
+                const child = node.children.get(hash);
+                if (!child) {
+                    break;
+                }
+                node = child;
+                if (node.value !== undefined) {
+                    best = {
+                        value: node.value,
+                        index,
+                        lastMatch: best
+                    };
+                }
+                if (!node.children) {
+                    break;
+                }
+            }
+        }
+        return best;
+    }
+    /**
+     * Finds the node at the specified path, or `undefined` if no node was found.
+     *
+     * @param query - The path to the node to search for
+     * @returns The trie node at the specified path, or `undefined` if no node was found
+     */
+    _findNodeAtPrefix(query, delimiter = this.delimiter) {
+        let node = this._root;
+        for (const { prefix } of LookupByPath._iteratePrefixes(query, delimiter)) {
+            if (!node.children) {
+                return undefined;
+            }
+            const child = node.children.get(prefix);
+            if (!child) {
+                return undefined;
+            }
+            node = child;
+        }
+        return node;
+    }
+}
+//# sourceMappingURL=LookupByPath.js.map

package/lib-esm/LookupByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LookupByPath.js","sourceRoot":"","sources":["../src/LookupByPath.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/**\n * A node in the path trie used in LookupByPath\n */\ninterface IPathTrieNode<TItem extends {}> {\n  /**\n   * The value that exactly matches the current relative path\n   */\n  value: TItem | undefined;\n\n  /**\n   * Child nodes by subfolder\n   */\n  children: Map<string, IPathTrieNode<TItem>> | undefined;\n}\n\n/**\n * Readonly view of a node in the path trie used in LookupByPath\n *\n * @remarks\n * This interface is used to facilitate parallel traversals for comparing two `LookupByPath` instances.\n *\n * @beta\n */\nexport interface IReadonlyPathTrieNode<TItem extends {}> {\n  /**\n   * The value that exactly matches the current relative path\n   */\n  readonly value: TItem | undefined;\n\n  /**\n   * Child nodes by subfolder\n   */\n  readonly children: ReadonlyMap<string, IReadonlyPathTrieNode<TItem>> | undefined;\n}\n\ninterface IPrefixEntry {\n  /**\n   * The prefix that was matched\n   */\n  prefix: string;\n\n  /**\n   * The index of the first character after the matched prefix\n   */\n  index: number;\n}\n\n/**\n * Object containing both the matched item and the start index of the remainder of the query.\n *\n * @beta\n */\nexport interface IPrefixMatch<TItem extends {}> {\n  /**\n   * The item that matched the prefix\n   */\n  value: TItem;\n\n  /**\n   * The index of the first character after the matched prefix\n   */\n  index: number;\n\n  /**\n   * The last match found (with a shorter prefix), if any\n   */\n  lastMatch?: IPrefixMatch<TItem>;\n}\n\n/**\n * The readonly component of `LookupByPath`, to simplify unit testing.\n *\n * @beta\n */\nexport interface IReadonlyLookupByPath<TItem extends {}> extends Iterable<[string, TItem]> {\n  /**\n   * Searches for the item associated with `childPath`, or the nearest ancestor of that path that\n   * has an associated item.\n   *\n   * @returns the found item, or `undefined` if no item was found\n   *\n   * @example\n   * ```ts\n   * const trie = new LookupByPath([['foo', 1], ['foo/bar', 2]]);\n   * trie.findChildPath('foo/baz'); // returns 1\n   * trie.findChildPath('foo/bar/baz'); // returns 2\n   * ```\n   */\n  findChildPath(childPath: string, delimiter?: string): TItem | undefined;\n\n  /**\n   * Searches for the item for which the recorded prefix is the longest matching prefix of `query`.\n   * Obtains both the item and the length of the matched prefix, so that the remainder of the path can be\n   * extracted.\n   *\n   * @returns the found item and the length of the matched prefix, or `undefined` if no item was found\n   *\n   * @example\n   * ```ts\n   * const trie = new LookupByPath([['foo', 1], ['foo/bar', 2]]);\n   * trie.findLongestPrefixMatch('foo/baz'); // returns { item: 1, index: 3 }\n   * trie.findLongestPrefixMatch('foo/bar/baz'); // returns { item: 2, index: 7 }\n   * ```\n   */\n  findLongestPrefixMatch(query: string, delimiter?: string): IPrefixMatch<TItem> | undefined;\n\n  /**\n   * Searches for the item associated with `childPathSegments`, or the nearest ancestor of that path that\n   * has an associated item.\n   *\n   * @returns the found item, or `undefined` if no item was found\n   *\n   * @example\n   * ```ts\n   * const trie = new LookupByPath([['foo', 1], ['foo/bar', 2]]);\n   * trie.findChildPathFromSegments(['foo', 'baz']); // returns 1\n   * trie.findChildPathFromSegments(['foo','bar', 'baz']); // returns 2\n   * ```\n   */\n  findChildPathFromSegments(childPathSegments: Iterable<string>): TItem | undefined;\n\n  /**\n   * Determines if an entry exists exactly at the specified path.\n   *\n   * @returns `true` if an entry exists at the specified path, `false` otherwise\n   */\n  has(query: string, delimiter?: string): boolean;\n\n  /**\n   * Retrieves the entry that exists exactly at the specified path, if any.\n   *\n   * @returns The entry that exists exactly at the specified path, or `undefined` if no entry exists.\n   */\n  get(query: string, delimiter?: string): TItem | undefined;\n\n  /**\n   * Gets the number of entries in this trie.\n   *\n   * @returns The number of entries in this trie.\n   */\n  get size(): number;\n\n  /**\n   * @returns The root node of the trie, corresponding to the path ''\n   */\n  get tree(): IReadonlyPathTrieNode<TItem>;\n\n  /**\n   * Iterates over the entries in this trie.\n   *\n   * @param query - An optional query. If specified only entries that start with the query will be returned.\n   *\n   * @returns An iterator over the entries under the specified query (or the root if no query is specified).\n   * @remarks\n   * Keys in the returned iterator use the provided delimiter to join segments.\n   * Iteration order is not specified.\n   * @example\n   * ```ts\n   * const trie = new LookupByPath([['foo', 1], ['foo/bar', 2]]);\n   * [...trie.entries(undefined, ',')); // returns [['foo', 1], ['foo,bar', 2]]\n   * ```\n   */\n  entries(query?: string, delimiter?: string): IterableIterator<[string, TItem]>;\n\n  /**\n   * Iterates over the entries in this trie.\n   *\n   * @param query - An optional query. If specified only entries that start with the query will be returned.\n   *\n   * @returns An iterator over the entries under the specified query (or the root if no query is specified).\n   * @remarks\n   * Keys in the returned iterator use the provided delimiter to join segments.\n   * Iteration order is not specified.\n   */\n  [Symbol.iterator](query?: string, delimiter?: string): IterableIterator<[string, TItem]>;\n\n  /**\n   * Groups the provided map of info by the nearest entry in the trie that contains the path. If the path\n   * is not found in the trie, the info is ignored.\n   *\n   * @returns The grouped info, grouped by the nearest entry in the trie that contains the path\n   *\n   * @param infoByPath - The info to be grouped, keyed by path\n   */\n  groupByChild<TInfo>(infoByPath: Map<string, TInfo>, delimiter?: string): Map<TItem, Map<string, TInfo>>;\n\n  /**\n   * Retrieves the trie node at the specified prefix, if it exists.\n   *\n   * @param query - The prefix to check for\n   * @param delimiter - The path delimiter\n   * @returns The trie node at the specified prefix, or `undefined` if no node was found\n   */\n  getNodeAtPrefix(query: string, delimiter?: string): IReadonlyPathTrieNode<TItem> | undefined;\n}\n\n/**\n * This class is used to associate path-like-strings, such as those returned by `git` commands,\n * with entities that correspond with ancestor folders, such as Rush Projects or npm packages.\n *\n * It is optimized for efficiently locating the nearest ancestor path with an associated value.\n *\n * It is implemented as a Trie (https://en.wikipedia.org/wiki/Trie) data structure, with each edge\n * being a path segment.\n *\n * @example\n * ```ts\n * const trie = new LookupByPath([['foo', 1], ['bar', 2], ['foo/bar', 3]]);\n * trie.findChildPath('foo'); // returns 1\n * trie.findChildPath('foo/baz'); // returns 1\n * trie.findChildPath('baz'); // returns undefined\n * trie.findChildPath('foo/bar/baz'); returns 3\n * trie.findChildPath('bar/foo/bar'); returns 2\n * ```\n * @beta\n */\nexport class LookupByPath<TItem extends {}> implements IReadonlyLookupByPath<TItem> {\n  /**\n   * The delimiter used to split paths\n   */\n  public readonly delimiter: string;\n\n  /**\n   * The root node of the trie, corresponding to the path ''\n   */\n  private readonly _root: IPathTrieNode<TItem>;\n\n  /**\n   * The number of entries in this trie.\n   */\n  private _size: number;\n\n  /**\n   * Constructs a new `LookupByPath`\n   *\n   * @param entries - Initial path-value pairs to populate the trie.\n   */\n  public constructor(entries?: Iterable<[string, TItem]>, delimiter?: string) {\n    this._root = {\n      value: undefined,\n      children: undefined\n    };\n\n    this.delimiter = delimiter ?? '/';\n    this._size = 0;\n\n    if (entries) {\n      for (const [path, item] of entries) {\n        this.setItem(path, item);\n      }\n    }\n  }\n\n  /**\n   * Iterates over the segments of a serialized path.\n   *\n   * @example\n   *\n   * `LookupByPath.iteratePathSegments('foo/bar/baz')` yields 'foo', 'bar', 'baz'\n   *\n   * `LookupByPath.iteratePathSegments('foo\\\\bar\\\\baz', '\\\\')` yields 'foo', 'bar', 'baz'\n   */\n  public static *iteratePathSegments(serializedPath: string, delimiter: string = '/'): Iterable<string> {\n    for (const prefixMatch of this._iteratePrefixes(serializedPath, delimiter)) {\n      yield prefixMatch.prefix;\n    }\n  }\n\n  private static *_iteratePrefixes(input: string, delimiter: string = '/'): Iterable<IPrefixEntry> {\n    if (!input) {\n      return;\n    }\n\n    let previousIndex: number = 0;\n    let nextIndex: number = input.indexOf(delimiter);\n\n    // Leading segments\n    while (nextIndex >= 0) {\n      yield {\n        prefix: input.slice(previousIndex, nextIndex),\n        index: nextIndex\n      };\n      previousIndex = nextIndex + 1;\n      nextIndex = input.indexOf(delimiter, previousIndex);\n    }\n\n    // Last segment\n    if (previousIndex < input.length) {\n      yield {\n        prefix: input.slice(previousIndex, input.length),\n        index: input.length\n      };\n    }\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath.size}\n   */\n  public get size(): number {\n    return this._size;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath.tree}\n   */\n  public get tree(): IReadonlyPathTrieNode<TItem> {\n    return this._root;\n  }\n\n  /**\n   * Deletes all entries from this `LookupByPath` instance.\n   *\n   * @returns this, for chained calls\n   */\n  public clear(): this {\n    this._root.value = undefined;\n    this._root.children = undefined;\n    this._size = 0;\n    return this;\n  }\n\n  /**\n   * Associates the value with the specified serialized path.\n   * If a value is already associated, will overwrite.\n   *\n   * @returns this, for chained calls\n   */\n  public setItem(serializedPath: string, value: TItem, delimiter: string = this.delimiter): this {\n    return this.setItemFromSegments(LookupByPath.iteratePathSegments(serializedPath, delimiter), value);\n  }\n\n  /**\n   * Deletes an item if it exists.\n   * @param query - The path to the item to delete\n   * @param delimeter - Optional override delimeter for parsing the query\n   * @returns `true` if the item was found and deleted, `false` otherwise\n   * @remarks\n   * If the node has children with values, they will be retained.\n   */\n  public deleteItem(query: string, delimeter: string = this.delimiter): boolean {\n    const node: IPathTrieNode<TItem> | undefined = this._findNodeAtPrefix(query, delimeter);\n    if (node?.value !== undefined) {\n      node.value = undefined;\n      this._size--;\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Deletes an item and all its children.\n   * @param query - The path to the item to delete\n   * @param delimeter - Optional override delimeter for parsing the query\n   * @returns `true` if any nodes were deleted, `false` otherwise\n   */\n  public deleteSubtree(query: string, delimeter: string = this.delimiter): boolean {\n    const queryNode: IPathTrieNode<TItem> | undefined = this._findNodeAtPrefix(query, delimeter);\n    if (!queryNode) {\n      return false;\n    }\n\n    const queue: IPathTrieNode<TItem>[] = [queryNode];\n    let removed: number = 0;\n    while (queue.length > 0) {\n      const node: IPathTrieNode<TItem> = queue.pop()!;\n      if (node.value !== undefined) {\n        node.value = undefined;\n        removed++;\n      }\n      if (node.children) {\n        for (const child of node.children.values()) {\n          queue.push(child);\n        }\n        node.children.clear();\n      }\n    }\n\n    this._size -= removed;\n    return removed > 0;\n  }\n\n  /**\n   * Associates the value with the specified path.\n   * If a value is already associated, will overwrite.\n   *\n   * @returns this, for chained calls\n   */\n  public setItemFromSegments(pathSegments: Iterable<string>, value: TItem): this {\n    let node: IPathTrieNode<TItem> = this._root;\n    for (const segment of pathSegments) {\n      if (!node.children) {\n        node.children = new Map();\n      }\n      let child: IPathTrieNode<TItem> | undefined = node.children.get(segment);\n      if (!child) {\n        node.children.set(\n          segment,\n          (child = {\n            value: undefined,\n            children: undefined\n          })\n        );\n      }\n      node = child;\n    }\n    if (node.value === undefined) {\n      this._size++;\n    }\n    node.value = value;\n\n    return this;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public findChildPath(childPath: string, delimiter: string = this.delimiter): TItem | undefined {\n    return this.findChildPathFromSegments(LookupByPath.iteratePathSegments(childPath, delimiter));\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public findLongestPrefixMatch(\n    query: string,\n    delimiter: string = this.delimiter\n  ): IPrefixMatch<TItem> | undefined {\n    return this._findLongestPrefixMatch(LookupByPath._iteratePrefixes(query, delimiter));\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public findChildPathFromSegments(childPathSegments: Iterable<string>): TItem | undefined {\n    let node: IPathTrieNode<TItem> = this._root;\n    let best: TItem | undefined = node.value;\n    // Trivial cases\n    if (node.children) {\n      for (const segment of childPathSegments) {\n        const child: IPathTrieNode<TItem> | undefined = node.children.get(segment);\n        if (!child) {\n          break;\n        }\n        node = child;\n        best = node.value ?? best;\n        if (!node.children) {\n          break;\n        }\n      }\n    }\n\n    return best;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public has(key: string, delimiter: string = this.delimiter): boolean {\n    const match: IPrefixMatch<TItem> | undefined = this.findLongestPrefixMatch(key, delimiter);\n    return match?.index === key.length;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public get(key: string, delimiter: string = this.delimiter): TItem | undefined {\n    const match: IPrefixMatch<TItem> | undefined = this.findLongestPrefixMatch(key, delimiter);\n    return match?.index === key.length ? match.value : undefined;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public groupByChild<TInfo>(\n    infoByPath: Map<string, TInfo>,\n    delimiter: string = this.delimiter\n  ): Map<TItem, Map<string, TInfo>> {\n    const groupedInfoByChild: Map<TItem, Map<string, TInfo>> = new Map();\n\n    for (const [path, info] of infoByPath) {\n      const child: TItem | undefined = this.findChildPath(path, delimiter);\n      if (child === undefined) {\n        continue;\n      }\n      let groupedInfo: Map<string, TInfo> | undefined = groupedInfoByChild.get(child);\n      if (!groupedInfo) {\n        groupedInfo = new Map();\n        groupedInfoByChild.set(child, groupedInfo);\n      }\n      groupedInfo.set(path, info);\n    }\n\n    return groupedInfoByChild;\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public *entries(query?: string, delimiter: string = this.delimiter): IterableIterator<[string, TItem]> {\n    let root: IPathTrieNode<TItem> | undefined;\n    if (query) {\n      root = this._findNodeAtPrefix(query, delimiter);\n      if (!root) {\n        return;\n      }\n    } else {\n      root = this._root;\n    }\n\n    const stack: [string, IPathTrieNode<TItem>][] = [[query ?? '', root]];\n    while (stack.length > 0) {\n      const [prefix, node] = stack.pop()!;\n      if (node.value !== undefined) {\n        yield [prefix, node.value];\n      }\n      if (node.children) {\n        for (const [segment, child] of node.children) {\n          stack.push([prefix ? `${prefix}${delimiter}${segment}` : segment, child]);\n        }\n      }\n    }\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public [Symbol.iterator](\n    query?: string,\n    delimiter: string = this.delimiter\n  ): IterableIterator<[string, TItem]> {\n    return this.entries(query, delimiter);\n  }\n\n  /**\n   * {@inheritdoc IReadonlyLookupByPath}\n   */\n  public getNodeAtPrefix(\n    query: string,\n    delimiter: string = this.delimiter\n  ): IReadonlyPathTrieNode<TItem> | undefined {\n    return this._findNodeAtPrefix(query, delimiter);\n  }\n\n  /**\n   * Iterates through progressively longer prefixes of a given string and returns as soon\n   * as the number of candidate items that match the prefix are 1 or 0.\n   *\n   * If a match is present, returns the matched itme and the length of the matched prefix.\n   *\n   * @returns the found item, or `undefined` if no item was found\n   */\n  private _findLongestPrefixMatch(prefixes: Iterable<IPrefixEntry>): IPrefixMatch<TItem> | undefined {\n    let node: IPathTrieNode<TItem> = this._root;\n    let best: IPrefixMatch<TItem> | undefined = node.value\n      ? {\n          value: node.value,\n          index: 0,\n          lastMatch: undefined\n        }\n      : undefined;\n    // Trivial cases\n    if (node.children) {\n      for (const { prefix: hash, index } of prefixes) {\n        const child: IPathTrieNode<TItem> | undefined = node.children.get(hash);\n        if (!child) {\n          break;\n        }\n        node = child;\n        if (node.value !== undefined) {\n          best = {\n            value: node.value,\n            index,\n            lastMatch: best\n          };\n        }\n        if (!node.children) {\n          break;\n        }\n      }\n    }\n\n    return best;\n  }\n\n  /**\n   * Finds the node at the specified path, or `undefined` if no node was found.\n   *\n   * @param query - The path to the node to search for\n   * @returns The trie node at the specified path, or `undefined` if no node was found\n   */\n  private _findNodeAtPrefix(\n    query: string,\n    delimiter: string = this.delimiter\n  ): IPathTrieNode<TItem> | undefined {\n    let node: IPathTrieNode<TItem> = this._root;\n    for (const { prefix } of LookupByPath._iteratePrefixes(query, delimiter)) {\n      if (!node.children) {\n        return undefined;\n      }\n      const child: IPathTrieNode<TItem> | undefined = node.children.get(prefix);\n      if (!child) {\n        return undefined;\n      }\n      node = child;\n    }\n    return node;\n  }\n}\n"]}

package/lib-esm/getFirstDifferenceInCommonNodes.js

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/**
+ * Recursively compares two path tries to find the first shared node with a different value.
+ *
+ * @param options - The options for the comparison
+ * @returns The path to the first differing node, or undefined if they are identical
+ *
+ * @remarks
+ * Ignores any nodes that are not shared between the two tries.
+ *
+ * @beta
+ */
+export function getFirstDifferenceInCommonNodes(options) {
+    const { first, second, prefix = '', delimiter = '/', equals = defaultEquals } = options;
+    return getFirstDifferenceInCommonNodesInternal({
+        first,
+        second,
+        prefix,
+        delimiter,
+        equals
+    });
+}
+/**
+ * Recursively compares two path tries to find the first shared node with a different value.
+ *
+ * @param options - The options for the comparison
+ * @returns The path to the first differing node, or undefined if they are identical
+ *
+ * @remarks
+ * Ignores any nodes that are not shared between the two tries.
+ * Separated out to avoid redundant parameter defaulting in the recursive calls.
+ */
+function getFirstDifferenceInCommonNodesInternal(options) {
+    const { first, second, prefix, delimiter, equals } = options;
+    const firstItem = first.value;
+    const secondItem = second.value;
+    if (firstItem !== undefined && secondItem !== undefined && !equals(firstItem, secondItem)) {
+        // If this value was present in both tries with different values, return the prefix for this node.
+        return prefix;
+    }
+    const { children: firstChildren } = first;
+    const { children: secondChildren } = second;
+    if (firstChildren && secondChildren) {
+        for (const [key, firstChild] of firstChildren) {
+            const secondChild = secondChildren.get(key);
+            if (!secondChild) {
+                continue;
+            }
+            const result = getFirstDifferenceInCommonNodesInternal({
+                first: firstChild,
+                second: secondChild,
+                prefix: key,
+                delimiter,
+                equals
+            });
+            if (result !== undefined) {
+                return prefix ? `${prefix}${delimiter}${result}` : result;
+            }
+        }
+    }
+    return;
+}
+/**
+ * Default equality function for comparing two items, using strict equality.
+ * @param a - The first item to compare
+ * @param b - The second item to compare
+ * @returns True if the items are reference equal, false otherwise
+ */
+function defaultEquals(a, b) {
+    return a === b;
+}
+//# sourceMappingURL=getFirstDifferenceInCommonNodes.js.map

package/lib-esm/getFirstDifferenceInCommonNodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFirstDifferenceInCommonNodes.js","sourceRoot":"","sources":["../src/getFirstDifferenceInCommonNodes.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAkC3D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAuD;IAEvD,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,EAAE,SAAS,GAAG,GAAG,EAAE,MAAM,GAAG,aAAa,EAAE,GAAG,OAAO,CAAC;IAExF,OAAO,uCAAuC,CAAC;QAC7C,KAAK;QACL,MAAM;QACN,MAAM;QACN,SAAS;QACT,MAAM;KACP,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,uCAAuC,CAC9C,OAAiE;IAEjE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAE7D,MAAM,SAAS,GAAsB,KAAK,CAAC,KAAK,CAAC;IACjD,MAAM,UAAU,GAAsB,MAAM,CAAC,KAAK,CAAC;IAEnD,IAAI,SAAS,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,CAAC;QAC1F,kGAAkG;QAClG,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC;IAC1C,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC;IAE5C,IAAI,aAAa,IAAI,cAAc,EAAE,CAAC;QACpC,KAAK,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,aAAa,EAAE,CAAC;YAC9C,MAAM,WAAW,GAA6C,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACtF,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,SAAS;YACX,CAAC;YACD,MAAM,MAAM,GAAuB,uCAAuC,CAAC;gBACzE,KAAK,EAAE,UAAU;gBACjB,MAAM,EAAE,WAAW;gBACnB,MAAM,EAAE,GAAG;gBACX,SAAS;gBACT,MAAM;aACP,CAAC,CAAC;YAEH,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YAC5D,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO;AACT,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAQ,CAAQ,EAAE,CAAQ;IAC9C,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type { IReadonlyPathTrieNode } from './LookupByPath';\n\n/**\n * Options for the getFirstDifferenceInCommonNodes function.\n * @beta\n */\nexport interface IGetFirstDifferenceInCommonNodesOptions<TItem extends {}> {\n  /**\n   * The first node to compare.\n   */\n  first: IReadonlyPathTrieNode<TItem>;\n  /**\n   * The second node to compare.\n   */\n  second: IReadonlyPathTrieNode<TItem>;\n  /**\n   * The path prefix to the current node.\n   * @defaultValue ''\n   */\n  prefix?: string;\n  /**\n   * The delimiter used to join path segments.\n   * @defaultValue '/'\n   */\n  delimiter?: string;\n  /**\n   * A function to compare the values of the nodes.\n   * If not provided, strict equality (===) is used.\n   */\n  equals?: (a: TItem, b: TItem) => boolean;\n}\n\n/**\n * Recursively compares two path tries to find the first shared node with a different value.\n *\n * @param options - The options for the comparison\n * @returns The path to the first differing node, or undefined if they are identical\n *\n * @remarks\n * Ignores any nodes that are not shared between the two tries.\n *\n * @beta\n */\nexport function getFirstDifferenceInCommonNodes<TItem extends {}>(\n  options: IGetFirstDifferenceInCommonNodesOptions<TItem>\n): string | undefined {\n  const { first, second, prefix = '', delimiter = '/', equals = defaultEquals } = options;\n\n  return getFirstDifferenceInCommonNodesInternal({\n    first,\n    second,\n    prefix,\n    delimiter,\n    equals\n  });\n}\n\n/**\n * Recursively compares two path tries to find the first shared node with a different value.\n *\n * @param options - The options for the comparison\n * @returns The path to the first differing node, or undefined if they are identical\n *\n * @remarks\n * Ignores any nodes that are not shared between the two tries.\n * Separated out to avoid redundant parameter defaulting in the recursive calls.\n */\nfunction getFirstDifferenceInCommonNodesInternal<TItem extends {}>(\n  options: Required<IGetFirstDifferenceInCommonNodesOptions<TItem>>\n): string | undefined {\n  const { first, second, prefix, delimiter, equals } = options;\n\n  const firstItem: TItem | undefined = first.value;\n  const secondItem: TItem | undefined = second.value;\n\n  if (firstItem !== undefined && secondItem !== undefined && !equals(firstItem, secondItem)) {\n    // If this value was present in both tries with different values, return the prefix for this node.\n    return prefix;\n  }\n\n  const { children: firstChildren } = first;\n  const { children: secondChildren } = second;\n\n  if (firstChildren && secondChildren) {\n    for (const [key, firstChild] of firstChildren) {\n      const secondChild: IReadonlyPathTrieNode<TItem> | undefined = secondChildren.get(key);\n      if (!secondChild) {\n        continue;\n      }\n      const result: string | undefined = getFirstDifferenceInCommonNodesInternal({\n        first: firstChild,\n        second: secondChild,\n        prefix: key,\n        delimiter,\n        equals\n      });\n\n      if (result !== undefined) {\n        return prefix ? `${prefix}${delimiter}${result}` : result;\n      }\n    }\n  }\n\n  return;\n}\n\n/**\n * Default equality function for comparing two items, using strict equality.\n * @param a - The first item to compare\n * @param b - The second item to compare\n * @returns True if the items are reference equal, false otherwise\n */\nfunction defaultEquals<TItem>(a: TItem, b: TItem): boolean {\n  return a === b;\n}\n"]}

package/lib-esm/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+export { LookupByPath } from './LookupByPath';
+export { getFirstDifferenceInCommonNodes } from './getFirstDifferenceInCommonNodes';
+//# sourceMappingURL=index.js.map

package/lib-esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAS3D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/**\n * Strongly typed trie data structure for path and URL-like strings.\n *\n * @packageDocumentation\n */\n\nexport type { IPrefixMatch, IReadonlyLookupByPath, IReadonlyPathTrieNode } from './LookupByPath';\nexport { LookupByPath } from './LookupByPath';\nexport type { IGetFirstDifferenceInCommonNodesOptions } from './getFirstDifferenceInCommonNodes';\nexport { getFirstDifferenceInCommonNodes } from './getFirstDifferenceInCommonNodes';\n"]}

package/package.json

@@ -1,9 +1,32 @@
 {
   "name": "@rushstack/lookup-by-path",
-  "version": "0.8.16",
+  "version": "0.9.1",
   "description": "Strongly typed trie data structure for path and URL-like strings.",
-  "main": "lib/index.js",
-  "typings": "dist/lookup-by-path.d.ts",
+  "main": "./lib-commonjs/index.js",
+  "module": "./lib-esm/index.js",
+  "types": "./dist/lookup-by-path.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/lookup-by-path.d.ts",
+      "node": "./lib-commonjs/index.js",
+      "import": "./lib-esm/index.js",
+      "require": "./lib-commonjs/index.js"
+    },
+    "./lib/*": {
+      "types": "./lib-dts/*.d.ts",
+      "node": "./lib-commonjs/*.js",
+      "import": "./lib-esm/*.js",
+      "require": "./lib-commonjs/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib-dts/*"
+      ]
+    }
+  },
   "keywords": [
     "trie",
     "path",
@@ -19,7 +42,7 @@
   },
   "devDependencies": {
     "eslint": "~9.37.0",
-    "@rushstack/heft": "1.1.14",
+    "@rushstack/heft": "1.2.1",
     "local-node-rig": "1.0.0"
   },
   "peerDependencies": {
@@ -30,6 +53,7 @@
       "optional": true
     }
   },
+  "sideEffects": false,
   "scripts": {
     "build": "heft build --clean",
     "_phase:build": "heft run --only build -- --clean",