@fluentui/react-tree 9.0.0-beta.3 → 9.0.0-beta.31

package/lib-commonjs/utils/ImmutableMap.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImmutableMap", {
+    enumerable: true,
+    get: ()=>ImmutableMap
+});
+const emptyImmutableMap = createImmutableMap();
+/**
+ * properly creates an ImmutableMap instance from an iterable
+ */ function createImmutableMap(iterable) {
+    const internalMap = new Map(iterable);
+    return dangerouslyCreateImmutableMap(internalMap);
+}
+/**
+ * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,
+ * @param internalMap - a set that is used internally to store values.
+ */ function dangerouslyCreateImmutableMap(internalMap) {
+    return {
+        size: internalMap.size,
+        set: (key, value)=>{
+            const nextSet = new Map(internalMap);
+            nextSet.set(key, value);
+            return dangerouslyCreateImmutableMap(nextSet);
+        },
+        get: (key)=>internalMap.get(key),
+        clear: ()=>emptyImmutableMap,
+        delete (value) {
+            const nextSet = new Map(internalMap);
+            nextSet.delete(value);
+            return dangerouslyCreateImmutableMap(nextSet);
+        },
+        has: (value)=>internalMap.has(value),
+        [Symbol.iterator]: ()=>internalMap[Symbol.iterator](),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        dangerouslyGetInternalMap_unstable: ()=>internalMap
+    };
+}
+function isImmutableMap(value) {
+    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;
+}
+const ImmutableMap = {
+    empty: emptyImmutableMap,
+    create: createImmutableMap,
+    isImmutableMap,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap
+};

package/lib-commonjs/utils/ImmutableMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ImmutableMap.js"],"sourcesContent":["const emptyImmutableMap = createImmutableMap();\n/**\n * properly creates an ImmutableMap instance from an iterable\n */ function createImmutableMap(iterable) {\n    const internalMap = new Map(iterable);\n    return dangerouslyCreateImmutableMap(internalMap);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,\n * @param internalMap - a set that is used internally to store values.\n */ function dangerouslyCreateImmutableMap(internalMap) {\n    return {\n        size: internalMap.size,\n        set: (key, value)=>{\n            const nextSet = new Map(internalMap);\n            nextSet.set(key, value);\n            return dangerouslyCreateImmutableMap(nextSet);\n        },\n        get: (key)=>internalMap.get(key),\n        clear: ()=>emptyImmutableMap,\n        delete (value) {\n            const nextSet = new Map(internalMap);\n            nextSet.delete(value);\n            return dangerouslyCreateImmutableMap(nextSet);\n        },\n        has: (value)=>internalMap.has(value),\n        [Symbol.iterator]: ()=>internalMap[Symbol.iterator](),\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        dangerouslyGetInternalMap_unstable: ()=>internalMap\n    };\n}\nfunction isImmutableMap(value) {\n    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;\n}\nexport const ImmutableMap = {\n    empty: emptyImmutableMap,\n    create: createImmutableMap,\n    isImmutableMap,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap\n};\n"],"names":["ImmutableMap","emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","empty","create","dangerouslyCreate_unstable"],"mappings":";;;;+BAkCaA;;aAAAA;;AAlCb,MAAMC,oBAAoBC;AAC1B;;CAEC,GAAG,SAASA,mBAAmBC,QAAQ,EAAE;IACtC,MAAMC,cAAc,IAAIC,IAAIF;IAC5B,OAAOG,8BAA8BF;AACzC;AACA;;;CAGC,GAAG,SAASE,8BAA8BF,WAAW,EAAE;IACpD,OAAO;QACHG,MAAMH,YAAYG,IAAI;QACtBC,KAAK,CAACC,KAAKC,QAAQ;YACf,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQH,GAAG,CAACC,KAAKC;YACjB,OAAOJ,8BAA8BK;QACzC;QACAC,KAAK,CAACH,MAAML,YAAYQ,GAAG,CAACH;QAC5BI,OAAO,IAAIZ;QACXa,QAAQJ,KAAK,EAAE;YACX,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACzC;QACAI,KAAK,CAACL,QAAQN,YAAYW,GAAG,CAACL;QAC9B,CAACM,OAAOC,QAAQ,CAAC,EAAE,IAAIb,WAAW,CAACY,OAAOC,QAAQ,CAAC;QACnD,gEAAgE;QAChEC,oCAAoC,IAAId;IAC5C;AACJ;AACA,SAASe,eAAeT,KAAK,EAAE;IAC3B,OAAO,OAAOA,UAAU,YAAYA,UAAU,IAAI,IAAI,wCAAwCA;AAClG;AACO,MAAMV,eAAe;IACxBoB,OAAOnB;IACPoB,QAAQnB;IACRiB;IACA,gEAAgE;IAChEG,4BAA4BhB;AAChC"}

package/lib-commonjs/utils/ImmutableSet.js

@@ -1,45 +1,54 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.dangerouslyCreateImmutableSet = exports.createImmutableSet = exports.emptyImmutableSet = void 0;
-exports.emptyImmutableSet = /*#__PURE__*/createImmutableSet();
-/**
- * properly creates an ImmutableSet instance from an iterable
- */
-function createImmutableSet(iterable) {
-  const internalSet = new Set(iterable);
-  return dangerouslyCreateImmutableSet(internalSet);
-}
-exports.createImmutableSet = createImmutableSet;
+Object.defineProperty(exports, "ImmutableSet", {
+    enumerable: true,
+    get: ()=>ImmutableSet
+});
+const emptyImmutableSet = createImmutableSet();
 /**
  * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,
  * @param internalSet - a set that is used internally to store values.
- */
-function dangerouslyCreateImmutableSet(internalSet) {
-  return {
-    size: internalSet.size,
-    add(value) {
-      const nextSet = new Set(internalSet);
-      nextSet.add(value);
-      return dangerouslyCreateImmutableSet(nextSet);
-    },
-    clear() {
-      return exports.emptyImmutableSet;
-    },
-    delete(value) {
-      const nextSet = new Set(internalSet);
-      nextSet.delete(value);
-      return dangerouslyCreateImmutableSet(nextSet);
-    },
-    has(value) {
-      return internalSet.has(value);
-    },
-    [Symbol.iterator]() {
-      return internalSet[Symbol.iterator]();
-    }
-  };
+ */ function dangerouslyCreateImmutableSet(internalSet) {
+    return {
+        size: internalSet.size,
+        add (value) {
+            const nextSet = new Set(internalSet);
+            nextSet.add(value);
+            return dangerouslyCreateImmutableSet(nextSet);
+        },
+        clear () {
+            return emptyImmutableSet;
+        },
+        delete (value) {
+            const nextSet = new Set(internalSet);
+            nextSet.delete(value);
+            return dangerouslyCreateImmutableSet(nextSet);
+        },
+        has (value) {
+            return internalSet.has(value);
+        },
+        [Symbol.iterator] () {
+            return internalSet[Symbol.iterator]();
+        },
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        dangerouslyGetInternalSet_unstable: ()=>internalSet
+    };
+}
+function isImmutableSet(value) {
+    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;
+}
+/**
+ * properly creates an ImmutableSet instance from an iterable
+ */ function createImmutableSet(iterable) {
+    const internalSet = new Set(iterable);
+    return dangerouslyCreateImmutableSet(internalSet);
 }
-exports.dangerouslyCreateImmutableSet = dangerouslyCreateImmutableSet;
-//# sourceMappingURL=ImmutableSet.js.map
+const ImmutableSet = {
+    empty: emptyImmutableSet,
+    create: createImmutableSet,
+    isImmutableSet,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet
+};

package/lib-commonjs/utils/ImmutableSet.js.map

@@ -1 +1 @@
-{"version":3,"names":["exports","emptyImmutableSet","createImmutableSet","iterable","internalSet","Set","dangerouslyCreateImmutableSet","size","add","value","nextSet","clear","delete","has","Symbol","iterator"],"sources":["../src/packages/react-components/react-tree/src/utils/ImmutableSet.ts"],"sourcesContent":["export interface ImmutableSet<Value> {\n  /**\n   * The number of (unique) elements in a ImmutableSet.\n   */\n  readonly size: number;\n  /**\n   * Creates a new ImmutableSet containing all previous element plus the one provided as argument\n   * @param value - new value to be included in the new ImmutableSet instance\n   */\n  add(value: Value): ImmutableSet<Value>;\n  /**\n   * Returns a reference to ImmutableSet.emptySet\n   */\n  clear(): ImmutableSet<Value>;\n  /**\n   * Creates a new ImmutableSet with the original items and removes a specified value from the new ImmutableSet.\n   */\n  delete(value: Value): ImmutableSet<Value>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the ImmutableSet or not.\n   */\n  has(value: Value): boolean;\n  /** Iterates over values in the ImmutableSet. */\n  [Symbol.iterator](): IterableIterator<Value>;\n}\n\nexport const emptyImmutableSet = createImmutableSet<never>();\n\n/**\n * properly creates an ImmutableSet instance from an iterable\n */\nexport function createImmutableSet<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n  const internalSet = new Set(iterable);\n  return dangerouslyCreateImmutableSet(internalSet);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */\nexport function dangerouslyCreateImmutableSet<Value>(internalSet: Set<Value>): ImmutableSet<Value> {\n  return {\n    size: internalSet.size,\n    add(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.add(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    clear() {\n      return emptyImmutableSet;\n    },\n    delete(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    has(value) {\n      return internalSet.has(value);\n    },\n    [Symbol.iterator]() {\n      return internalSet[Symbol.iterator]();\n    },\n  };\n}\n"],"mappings":";;;;;;AA0BaA,OAAA,CAAAC,iBAAiB,gBAAGC,kBAAkB,EAAS;AAE5D;;;AAGA,SAAgBA,kBAAkBA,CAAQC,QAA0B;EAClE,MAAMC,WAAW,GAAG,IAAIC,GAAG,CAACF,QAAQ,CAAC;EACrC,OAAOG,6BAA6B,CAACF,WAAW,CAAC;AACnD;AAHAJ,OAAA,CAAAE,kBAAA,GAAAA,kBAAA;AAIA;;;;AAIA,SAAgBI,6BAA6BA,CAAQF,WAAuB;EAC1E,OAAO;IACLG,IAAI,EAAEH,WAAW,CAACG,IAAI;IACtBC,GAAGA,CAACC,KAAK;MACP,MAAMC,OAAO,GAAG,IAAIL,GAAG,CAACD,WAAW,CAAC;MACpCM,OAAO,CAACF,GAAG,CAACC,KAAK,CAAC;MAClB,OAAOH,6BAA6B,CAACI,OAAO,CAAC;IAC/C,CAAC;IACDC,KAAKA,CAAA;MACH,OAAOX,OAAA,CAAAC,iBAAiB;IAC1B,CAAC;IACDW,MAAMA,CAACH,KAAK;MACV,MAAMC,OAAO,GAAG,IAAIL,GAAG,CAACD,WAAW,CAAC;MACpCM,OAAO,CAACE,MAAM,CAACH,KAAK,CAAC;MACrB,OAAOH,6BAA6B,CAACI,OAAO,CAAC;IAC/C,CAAC;IACDG,GAAGA,CAACJ,KAAK;MACP,OAAOL,WAAW,CAACS,GAAG,CAACJ,KAAK,CAAC;IAC/B,CAAC;IACD,CAACK,MAAM,CAACC,QAAQ,IAAC;MACf,OAAOX,WAAW,CAACU,MAAM,CAACC,QAAQ,CAAC,EAAE;IACvC;GACD;AACH;AAvBAf,OAAA,CAAAM,6BAAA,GAAAA,6BAAA"}
+{"version":3,"sources":["ImmutableSet.js"],"sourcesContent":["const emptyImmutableSet = createImmutableSet();\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */ function dangerouslyCreateImmutableSet(internalSet) {\n    return {\n        size: internalSet.size,\n        add (value) {\n            const nextSet = new Set(internalSet);\n            nextSet.add(value);\n            return dangerouslyCreateImmutableSet(nextSet);\n        },\n        clear () {\n            return emptyImmutableSet;\n        },\n        delete (value) {\n            const nextSet = new Set(internalSet);\n            nextSet.delete(value);\n            return dangerouslyCreateImmutableSet(nextSet);\n        },\n        has (value) {\n            return internalSet.has(value);\n        },\n        [Symbol.iterator] () {\n            return internalSet[Symbol.iterator]();\n        },\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        dangerouslyGetInternalSet_unstable: ()=>internalSet\n    };\n}\nfunction isImmutableSet(value) {\n    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;\n}\n/**\n * properly creates an ImmutableSet instance from an iterable\n */ function createImmutableSet(iterable) {\n    const internalSet = new Set(iterable);\n    return dangerouslyCreateImmutableSet(internalSet);\n}\nexport const ImmutableSet = {\n    empty: emptyImmutableSet,\n    create: createImmutableSet,\n    isImmutableSet,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet\n};\n"],"names":["ImmutableSet","emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","empty","create","dangerouslyCreate_unstable"],"mappings":";;;;+BAuCaA;;aAAAA;;AAvCb,MAAMC,oBAAoBC;AAC1B;;;CAGC,GAAG,SAASC,8BAA8BC,WAAW,EAAE;IACpD,OAAO;QACHC,MAAMD,YAAYC,IAAI;QACtBC,KAAKC,KAAK,EAAE;YACR,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACzC;QACAE,SAAS;YACL,OAAOT;QACX;QACAU,QAAQJ,KAAK,EAAE;YACX,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACzC;QACAI,KAAKL,KAAK,EAAE;YACR,OAAOH,YAAYQ,GAAG,CAACL;QAC3B;QACA,CAACM,OAAOC,QAAQ,CAAC,IAAI;YACjB,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACvC;QACA,gEAAgE;QAChEC,oCAAoC,IAAIX;IAC5C;AACJ;AACA,SAASY,eAAeT,KAAK,EAAE;IAC3B,OAAO,OAAOA,UAAU,YAAYA,UAAU,IAAI,IAAI,wCAAwCA;AAClG;AACA;;CAEC,GAAG,SAASL,mBAAmBe,QAAQ,EAAE;IACtC,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACzC;AACO,MAAMJ,eAAe;IACxBkB,OAAOjB;IACPkB,QAAQjB;IACRc;IACA,gEAAgE;IAChEI,4BAA4BjB;AAChC"}

package/lib-commonjs/utils/assert.js

@@ -1,14 +1,16 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.assertIsDefinedRef = void 0;
+Object.defineProperty(exports, "assertIsDefinedRef", {
+    enumerable: true,
+    get: ()=>assertIsDefinedRef
+});
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
 function assertIsDefinedRef(refObject, msg = `assertIsDefinedRef: reference not properly defined ${refObject}`) {
-  // eslint-disable-next-line eqeqeq
-  if (refObject.current == undefined && process.env.NODE_ENV === 'development') {
-    throw new TypeError(msg);
-  }
+    // eslint-disable-next-line eqeqeq
+    if (refObject.current == undefined && process.env.NODE_ENV === 'development') {
+        throw new TypeError(msg);
+    }
 }
-exports.assertIsDefinedRef = assertIsDefinedRef;
-//# sourceMappingURL=assert.js.map

package/lib-commonjs/utils/assert.js.map

@@ -1 +1 @@
-{"version":3,"names":["assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError","exports"],"sources":["../src/packages/react-components/react-tree/src/utils/assert.ts"],"sourcesContent":["import * as React from 'react';\n\nexport function assertIsDefinedRef<V>(\n  refObject: React.RefObject<V | null | undefined>,\n  msg = `assertIsDefinedRef: reference not properly defined ${refObject}`,\n): asserts refObject is React.MutableRefObject<V> {\n  // eslint-disable-next-line eqeqeq\n  if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n    throw new TypeError(msg);\n  }\n}\n"],"mappings":";;;;;;AAEA,SAAgBA,kBAAkBA,CAChCC,SAAgD,EAChDC,GAAG,GAAG,sDAAsDD,SAAS,EAAE;EAEvE;EACA,IAAIA,SAAS,CAACE,OAAO,IAAIC,SAAS,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,aAAa,EAAE;IAC5E,MAAM,IAAIC,SAAS,CAACN,GAAG,CAAC;;AAE5B;AARAO,OAAA,CAAAT,kBAAA,GAAAA,kBAAA"}
+{"version":3,"sources":["assert.js"],"sourcesContent":["import * as React from 'react';\nexport function assertIsDefinedRef(refObject, msg = `assertIsDefinedRef: reference not properly defined ${refObject}`) {\n    // eslint-disable-next-line eqeqeq\n    if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n        throw new TypeError(msg);\n    }\n}\n"],"names":["assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"mappings":";;;;+BACgBA;;aAAAA;;;6DADO;AAChB,SAASA,mBAAmBC,SAAS,EAAEC,MAAM,CAAC,mDAAmD,EAAED,UAAU,CAAC,EAAE;IACnH,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1E,MAAM,IAAIC,UAAUN,KAAK;IAC7B,CAAC;AACL"}

package/lib-commonjs/utils/createCheckedItems.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createCheckedItems", {
+    enumerable: true,
+    get: ()=>createCheckedItems
+});
+const _immutableMap = require("./ImmutableMap");
+function createCheckedItems(iterable) {
+    if (iterable === undefined) {
+        return _immutableMap.ImmutableMap.empty;
+    }
+    if (_immutableMap.ImmutableMap.isImmutableMap(iterable)) {
+        return iterable;
+    }
+    const internalMap = new Map();
+    for (const item of iterable){
+        if (Array.isArray(item)) {
+            internalMap.set(item[0], item[1]);
+        } else {
+            internalMap.set(item, true);
+        }
+    }
+    return _immutableMap.ImmutableMap.dangerouslyCreate_unstable(internalMap);
+}

package/lib-commonjs/utils/createCheckedItems.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createCheckedItems.js"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nexport function createCheckedItems(iterable) {\n    if (iterable === undefined) {\n        return ImmutableMap.empty;\n    }\n    if (ImmutableMap.isImmutableMap(iterable)) {\n        return iterable;\n    }\n    const internalMap = new Map();\n    for (const item of iterable){\n        if (Array.isArray(item)) {\n            internalMap.set(item[0], item[1]);\n        } else {\n            internalMap.set(item, true);\n        }\n    }\n    return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["createCheckedItems","iterable","undefined","ImmutableMap","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"mappings":";;;;+BACgBA;;aAAAA;;8BADa;AACtB,SAASA,mBAAmBC,QAAQ,EAAE;IACzC,IAAIA,aAAaC,WAAW;QACxB,OAAOC,0BAAY,CAACC,KAAK;IAC7B,CAAC;IACD,IAAID,0BAAY,CAACE,cAAc,CAACJ,WAAW;QACvC,OAAOA;IACX,CAAC;IACD,MAAMK,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQP,SAAS;QACxB,IAAIQ,MAAMC,OAAO,CAACF,OAAO;YACrBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QACpC,OAAO;YACHF,YAAYK,GAAG,CAACH,MAAM,IAAI;QAC9B,CAAC;IACL;IACA,OAAOL,0BAAY,CAACS,0BAA0B,CAACN;AACnD"}

package/lib-commonjs/utils/createHTMLElementWalker.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createHTMLElementWalker", {
+    enumerable: true,
+    get: ()=>createHTMLElementWalker
+});
+const _reactUtilities = require("@fluentui/react-utilities");
+function createHTMLElementWalker(root, filter = ()=>NodeFilter.FILTER_ACCEPT) {
+    let temporaryFilter;
+    const treeWalker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+        acceptNode (node) {
+            if (!(0, _reactUtilities.isHTMLElement)(node)) {
+                return NodeFilter.FILTER_REJECT;
+            }
+            const filterResult = filter(node);
+            var _temporaryFilter;
+            return filterResult === NodeFilter.FILTER_ACCEPT ? (_temporaryFilter = temporaryFilter === null || temporaryFilter === void 0 ? void 0 : temporaryFilter(node)) !== null && _temporaryFilter !== void 0 ? _temporaryFilter : filterResult : filterResult;
+        }
+    });
+    return {
+        get root () {
+            return treeWalker.root;
+        },
+        get currentElement () {
+            return treeWalker.currentNode;
+        },
+        set currentElement (element){
+            treeWalker.currentNode = element;
+        },
+        firstChild: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.firstChild();
+            temporaryFilter = undefined;
+            return result;
+        },
+        lastChild: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.lastChild();
+            temporaryFilter = undefined;
+            return result;
+        },
+        nextElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.nextNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        nextSibling: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.nextSibling();
+            temporaryFilter = undefined;
+            return result;
+        },
+        parentElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.parentNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        previousElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.previousNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        previousSibling: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.previousSibling();
+            temporaryFilter = undefined;
+            return result;
+        }
+    };
+}

package/lib-commonjs/utils/createHTMLElementWalker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createHTMLElementWalker.js"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\nexport function createHTMLElementWalker(root, filter = ()=>NodeFilter.FILTER_ACCEPT) {\n    let temporaryFilter;\n    const treeWalker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n        acceptNode (node) {\n            if (!isHTMLElement(node)) {\n                return NodeFilter.FILTER_REJECT;\n            }\n            const filterResult = filter(node);\n            var _temporaryFilter;\n            return filterResult === NodeFilter.FILTER_ACCEPT ? (_temporaryFilter = temporaryFilter === null || temporaryFilter === void 0 ? void 0 : temporaryFilter(node)) !== null && _temporaryFilter !== void 0 ? _temporaryFilter : filterResult : filterResult;\n        }\n    });\n    return {\n        get root () {\n            return treeWalker.root;\n        },\n        get currentElement () {\n            return treeWalker.currentNode;\n        },\n        set currentElement (element){\n            treeWalker.currentNode = element;\n        },\n        firstChild: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.firstChild();\n            temporaryFilter = undefined;\n            return result;\n        },\n        lastChild: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.lastChild();\n            temporaryFilter = undefined;\n            return result;\n        },\n        nextElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.nextNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        nextSibling: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.nextSibling();\n            temporaryFilter = undefined;\n            return result;\n        },\n        parentElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.parentNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        previousElement: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.previousNode();\n            temporaryFilter = undefined;\n            return result;\n        },\n        previousSibling: (localFilter)=>{\n            temporaryFilter = localFilter;\n            const result = treeWalker.previousSibling();\n            temporaryFilter = undefined;\n            return result;\n        }\n    };\n}\n"],"names":["createHTMLElementWalker","root","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","document","createTreeWalker","SHOW_ELEMENT","acceptNode","node","isHTMLElement","FILTER_REJECT","filterResult","_temporaryFilter","currentElement","currentNode","element","firstChild","localFilter","result","undefined","lastChild","nextElement","nextNode","nextSibling","parentElement","parentNode","previousElement","previousNode","previousSibling"],"mappings":";;;;+BACgBA;;aAAAA;;gCADc;AACvB,SAASA,wBAAwBC,IAAI,EAAEC,SAAS,IAAIC,WAAWC,aAAa,EAAE;IACjF,IAAIC;IACJ,MAAMC,aAAaC,SAASC,gBAAgB,CAACP,MAAME,WAAWM,YAAY,EAAE;QACxEC,YAAYC,IAAI,EAAE;YACd,IAAI,CAACC,IAAAA,6BAAa,EAACD,OAAO;gBACtB,OAAOR,WAAWU,aAAa;YACnC,CAAC;YACD,MAAMC,eAAeZ,OAAOS;YAC5B,IAAII;YACJ,OAAOD,iBAAiBX,WAAWC,aAAa,GAAG,AAACW,CAAAA,mBAAmBV,oBAAoB,IAAI,IAAIA,oBAAoB,KAAK,IAAI,KAAK,IAAIA,gBAAgBM,KAAK,AAAD,MAAO,IAAI,IAAII,qBAAqB,KAAK,IAAIA,mBAAmBD,YAAY,GAAGA,YAAY;QAC5P;IACJ;IACA,OAAO;QACH,IAAIb,QAAQ;YACR,OAAOK,WAAWL,IAAI;QAC1B;QACA,IAAIe,kBAAkB;YAClB,OAAOV,WAAWW,WAAW;QACjC;QACA,IAAID,gBAAgBE,QAAQ;YACxBZ,WAAWW,WAAW,GAAGC;QAC7B;QACAC,YAAY,CAACC,cAAc;YACvBf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWa,UAAU;YACpCd,kBAAkBiB;YAClB,OAAOD;QACX;QACAE,WAAW,CAACH,cAAc;YACtBf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWiB,SAAS;YACnClB,kBAAkBiB;YAClB,OAAOD;QACX;QACAG,aAAa,CAACJ,cAAc;YACxBf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWmB,QAAQ;YAClCpB,kBAAkBiB;YAClB,OAAOD;QACX;QACAK,aAAa,CAACN,cAAc;YACxBf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWoB,WAAW;YACrCrB,kBAAkBiB;YAClB,OAAOD;QACX;QACAM,eAAe,CAACP,cAAc;YAC1Bf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWsB,UAAU;YACpCvB,kBAAkBiB;YAClB,OAAOD;QACX;QACAQ,iBAAiB,CAACT,cAAc;YAC5Bf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWwB,YAAY;YACtCzB,kBAAkBiB;YAClB,OAAOD;QACX;QACAU,iBAAiB,CAACX,cAAc;YAC5Bf,kBAAkBe;YAClB,MAAMC,SAASf,WAAWyB,eAAe;YACzC1B,kBAAkBiB;YAClB,OAAOD;QACX;IACJ;AACJ"}

package/lib-commonjs/utils/createHeadlessTree.js

@@ -0,0 +1,203 @@
+/**
+ * creates a list of virtual tree items
+ * and provides a map to access each item by id
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createHeadlessTree: ()=>createHeadlessTree,
+    headlessTreeRootId: ()=>headlessTreeRootId
+});
+function createHeadlessTree(initialProps = []) {
+    const root = createHeadlessTreeRootItem();
+    const itemsPerValue = new Map([
+        [
+            root.value,
+            root
+        ]
+    ]);
+    var _itemsPerValue_get_parentValue, _itemsPerValue_get;
+    const headlessTree = {
+        root,
+        get size () {
+            return itemsPerValue.size;
+        },
+        getParent: (key)=>{
+            var _itemsPerValue_get1;
+            return (_itemsPerValue_get = itemsPerValue.get((_itemsPerValue_get_parentValue = (_itemsPerValue_get1 = itemsPerValue.get(key)) === null || _itemsPerValue_get1 === void 0 ? void 0 : _itemsPerValue_get1.parentValue) !== null && _itemsPerValue_get_parentValue !== void 0 ? _itemsPerValue_get_parentValue : root.value)) !== null && _itemsPerValue_get !== void 0 ? _itemsPerValue_get : root;
+        },
+        get: (key)=>itemsPerValue.get(key),
+        has: (key)=>itemsPerValue.has(key),
+        add (props) {
+            const { parentValue =headlessTreeRootId , ...propsWithoutParentValue } = props;
+            const parentItem = itemsPerValue.get(parentValue);
+            if (!parentItem) {
+                if (process.env.NODE_ENV === 'development') {
+                    // eslint-disable-next-line no-console
+                    console.error(`HeadlessTree: item ${props.value} is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children`);
+                }
+                return;
+            }
+            parentItem.itemType = 'branch';
+            var _propsWithoutParentValue_itemType;
+            const item = {
+                value: props.value,
+                getTreeItemProps: ()=>({
+                        ...propsWithoutParentValue,
+                        'aria-level': item.level,
+                        'aria-posinset': item.position,
+                        'aria-setsize': parentItem.childrenValues.length,
+                        itemType: item.itemType
+                    }),
+                itemType: (_propsWithoutParentValue_itemType = propsWithoutParentValue.itemType) !== null && _propsWithoutParentValue_itemType !== void 0 ? _propsWithoutParentValue_itemType : 'leaf',
+                level: parentItem.level + 1,
+                parentValue,
+                childrenValues: [],
+                index: -1,
+                position: parentItem.childrenValues.push(props.value)
+            };
+            itemsPerValue.set(item.value, item);
+        },
+        // TODO: eventually it would be nice to have this method exported for the user to modify
+        // the internal state of the virtual tree
+        // remove(value) {
+        //   const itemToBeRemoved = itemsPerValue.get(value);
+        //   if (!itemToBeRemoved) {
+        //     return;
+        //   }
+        //   const parentItem = headlessTree.getParent(value);
+        //   parentItem.childrenValues.splice(itemToBeRemoved.position, 1);
+        //   itemsPerValue.delete(value);
+        //   if (parentItem.childrenValues.length === 0) {
+        //     parentItem.itemType = 'leaf';
+        //   }
+        //   for (let index = itemToBeRemoved.position; index < parentItem.childrenValues.length; index++) {
+        //     const child = itemsPerValue.get(parentItem.childrenValues[index]);
+        //     if (child) {
+        //       child.position = index + 1;
+        //     }
+        //   }
+        //   for (const descendant of HeadlessTreeSubtreeGenerator(value, headlessTree)) {
+        //     itemsPerValue.delete(descendant.value);
+        //   }
+        // },
+        subtree: (key)=>HeadlessTreeSubtreeGenerator(key, headlessTree),
+        children: (key)=>HeadlessTreeChildrenGenerator(key, headlessTree),
+        ancestors: (key)=>HeadlessTreeAncestorsGenerator(key, headlessTree),
+        visibleItems: (openItems)=>HeadlessTreeVisibleItemsGenerator(openItems, headlessTree)
+    };
+    initialProps.forEach(headlessTree.add);
+    return headlessTree;
+}
+const headlessTreeRootId = '__fuiHeadlessTreeRoot';
+function createHeadlessTreeRootItem() {
+    return {
+        parentValue: undefined,
+        value: headlessTreeRootId,
+        itemType: 'branch',
+        getTreeItemProps: ()=>{
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return {
+                id: headlessTreeRootId,
+                value: headlessTreeRootId,
+                'aria-setsize': -1,
+                'aria-level': -1,
+                'aria-posinset': -1,
+                itemType: 'branch'
+            };
+        },
+        childrenValues: [],
+        get index () {
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return -1;
+        },
+        get position () {
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return -1;
+        },
+        level: 0
+    };
+}
+/**
+ * Generator that returns all subtree of a given virtual tree item
+ * @param key the key of the item to get the subtree from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeSubtreeGenerator(key, virtualTreeItems) {
+    const item = virtualTreeItems.get(key);
+    if (!item || item.childrenValues.length === 0) {
+        return;
+    }
+    for (const childValue of item.childrenValues){
+        yield virtualTreeItems.get(childValue);
+        yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);
+    }
+}
+/**
+ * Generator that returns all children of a given virtual tree item
+ * @param key the key of the item to get the children from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeChildrenGenerator(key, virtualTreeItems) {
+    const item = virtualTreeItems.get(key);
+    if (!item || item.childrenValues.length === 0) {
+        return;
+    }
+    for (const childValue of item.childrenValues){
+        yield virtualTreeItems.get(childValue);
+    }
+}
+/**
+ * Generator that returns all ancestors of a given virtual tree item
+ * @param key the key of the item to get the children from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeAncestorsGenerator(key, virtualTreeItems) {
+    let parent = virtualTreeItems.getParent(key);
+    while(parent !== virtualTreeItems.root){
+        yield parent;
+        parent = virtualTreeItems.getParent(parent.value);
+    }
+}
+/**
+ * Generator that returns all visible items of a given virtual tree
+ * @param openItems the open items of the tree
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems) {
+    let index = 0;
+    for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)){
+        if (isItemVisible(item, openItems, virtualTreeItems)) {
+            item.index = index++;
+            yield item;
+        }
+    }
+}
+function isItemVisible(item, openItems, virtualTreeItems) {
+    if (item.level === 1) {
+        return true;
+    }
+    while(item.parentValue && item.parentValue !== virtualTreeItems.root.value){
+        if (!openItems.has(item.parentValue)) {
+            return false;
+        }
+        const parent = virtualTreeItems.get(item.parentValue);
+        if (!parent) {
+            return false;
+        }
+        item = parent;
+    }
+    return true;
+}

package/lib-commonjs/utils/createHeadlessTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createHeadlessTree.js"],"sourcesContent":["/**\n * creates a list of virtual tree items\n * and provides a map to access each item by id\n */ export function createHeadlessTree(initialProps = []) {\n    const root = createHeadlessTreeRootItem();\n    const itemsPerValue = new Map([\n        [\n            root.value,\n            root\n        ]\n    ]);\n    var _itemsPerValue_get_parentValue, _itemsPerValue_get;\n    const headlessTree = {\n        root,\n        get size () {\n            return itemsPerValue.size;\n        },\n        getParent: (key)=>{\n            var _itemsPerValue_get1;\n            return (_itemsPerValue_get = itemsPerValue.get((_itemsPerValue_get_parentValue = (_itemsPerValue_get1 = itemsPerValue.get(key)) === null || _itemsPerValue_get1 === void 0 ? void 0 : _itemsPerValue_get1.parentValue) !== null && _itemsPerValue_get_parentValue !== void 0 ? _itemsPerValue_get_parentValue : root.value)) !== null && _itemsPerValue_get !== void 0 ? _itemsPerValue_get : root;\n        },\n        get: (key)=>itemsPerValue.get(key),\n        has: (key)=>itemsPerValue.has(key),\n        add (props) {\n            const { parentValue =headlessTreeRootId , ...propsWithoutParentValue } = props;\n            const parentItem = itemsPerValue.get(parentValue);\n            if (!parentItem) {\n                if (process.env.NODE_ENV === 'development') {\n                    // eslint-disable-next-line no-console\n                    console.error(`HeadlessTree: item ${props.value} is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children`);\n                }\n                return;\n            }\n            parentItem.itemType = 'branch';\n            var _propsWithoutParentValue_itemType;\n            const item = {\n                value: props.value,\n                getTreeItemProps: ()=>({\n                        ...propsWithoutParentValue,\n                        'aria-level': item.level,\n                        'aria-posinset': item.position,\n                        'aria-setsize': parentItem.childrenValues.length,\n                        itemType: item.itemType\n                    }),\n                itemType: (_propsWithoutParentValue_itemType = propsWithoutParentValue.itemType) !== null && _propsWithoutParentValue_itemType !== void 0 ? _propsWithoutParentValue_itemType : 'leaf',\n                level: parentItem.level + 1,\n                parentValue,\n                childrenValues: [],\n                index: -1,\n                position: parentItem.childrenValues.push(props.value)\n            };\n            itemsPerValue.set(item.value, item);\n        },\n        // TODO: eventually it would be nice to have this method exported for the user to modify\n        // the internal state of the virtual tree\n        // remove(value) {\n        //   const itemToBeRemoved = itemsPerValue.get(value);\n        //   if (!itemToBeRemoved) {\n        //     return;\n        //   }\n        //   const parentItem = headlessTree.getParent(value);\n        //   parentItem.childrenValues.splice(itemToBeRemoved.position, 1);\n        //   itemsPerValue.delete(value);\n        //   if (parentItem.childrenValues.length === 0) {\n        //     parentItem.itemType = 'leaf';\n        //   }\n        //   for (let index = itemToBeRemoved.position; index < parentItem.childrenValues.length; index++) {\n        //     const child = itemsPerValue.get(parentItem.childrenValues[index]);\n        //     if (child) {\n        //       child.position = index + 1;\n        //     }\n        //   }\n        //   for (const descendant of HeadlessTreeSubtreeGenerator(value, headlessTree)) {\n        //     itemsPerValue.delete(descendant.value);\n        //   }\n        // },\n        subtree: (key)=>HeadlessTreeSubtreeGenerator(key, headlessTree),\n        children: (key)=>HeadlessTreeChildrenGenerator(key, headlessTree),\n        ancestors: (key)=>HeadlessTreeAncestorsGenerator(key, headlessTree),\n        visibleItems: (openItems)=>HeadlessTreeVisibleItemsGenerator(openItems, headlessTree)\n    };\n    initialProps.forEach(headlessTree.add);\n    return headlessTree;\n}\nexport const headlessTreeRootId = '__fuiHeadlessTreeRoot';\nfunction createHeadlessTreeRootItem() {\n    return {\n        parentValue: undefined,\n        value: headlessTreeRootId,\n        itemType: 'branch',\n        getTreeItemProps: ()=>{\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\n            }\n            return {\n                id: headlessTreeRootId,\n                value: headlessTreeRootId,\n                'aria-setsize': -1,\n                'aria-level': -1,\n                'aria-posinset': -1,\n                itemType: 'branch'\n            };\n        },\n        childrenValues: [],\n        get index () {\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\n            }\n            return -1;\n        },\n        get position () {\n            if (process.env.NODE_ENV !== 'production') {\n                // eslint-disable-next-line no-console\n                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\n            }\n            return -1;\n        },\n        level: 0\n    };\n}\n/**\n * Generator that returns all subtree of a given virtual tree item\n * @param key the key of the item to get the subtree from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeSubtreeGenerator(key, virtualTreeItems) {\n    const item = virtualTreeItems.get(key);\n    if (!item || item.childrenValues.length === 0) {\n        return;\n    }\n    for (const childValue of item.childrenValues){\n        yield virtualTreeItems.get(childValue);\n        yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);\n    }\n}\n/**\n * Generator that returns all children of a given virtual tree item\n * @param key the key of the item to get the children from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeChildrenGenerator(key, virtualTreeItems) {\n    const item = virtualTreeItems.get(key);\n    if (!item || item.childrenValues.length === 0) {\n        return;\n    }\n    for (const childValue of item.childrenValues){\n        yield virtualTreeItems.get(childValue);\n    }\n}\n/**\n * Generator that returns all ancestors of a given virtual tree item\n * @param key the key of the item to get the children from\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeAncestorsGenerator(key, virtualTreeItems) {\n    let parent = virtualTreeItems.getParent(key);\n    while(parent !== virtualTreeItems.root){\n        yield parent;\n        parent = virtualTreeItems.getParent(parent.value);\n    }\n}\n/**\n * Generator that returns all visible items of a given virtual tree\n * @param openItems the open items of the tree\n */ // eslint-disable-next-line @typescript-eslint/naming-convention\nfunction* HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems) {\n    let index = 0;\n    for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)){\n        if (isItemVisible(item, openItems, virtualTreeItems)) {\n            item.index = index++;\n            yield item;\n        }\n    }\n}\nfunction isItemVisible(item, openItems, virtualTreeItems) {\n    if (item.level === 1) {\n        return true;\n    }\n    while(item.parentValue && item.parentValue !== virtualTreeItems.root.value){\n        if (!openItems.has(item.parentValue)) {\n            return false;\n        }\n        const parent = virtualTreeItems.get(item.parentValue);\n        if (!parent) {\n            return false;\n        }\n        item = parent;\n    }\n    return true;\n}\n"],"names":["createHeadlessTree","headlessTreeRootId","initialProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","_itemsPerValue_get_parentValue","_itemsPerValue_get","headlessTree","size","getParent","key","_itemsPerValue_get1","get","parentValue","has","add","props","propsWithoutParentValue","parentItem","process","env","NODE_ENV","console","error","itemType","_propsWithoutParentValue_itemType","item","getTreeItemProps","level","position","childrenValues","length","index","push","set","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","forEach","undefined","id","virtualTreeItems","childValue","parent","isItemVisible"],"mappings":"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"}

package/lib-commonjs/utils/createOpenItems.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createOpenItems", {
+    enumerable: true,
+    get: ()=>createOpenItems
+});
+const _immutableSet = require("./ImmutableSet");
+function createOpenItems(iterable) {
+    if (iterable === undefined) {
+        return _immutableSet.ImmutableSet.empty;
+    }
+    if (_immutableSet.ImmutableSet.isImmutableSet(iterable)) {
+        return iterable;
+    }
+    return _immutableSet.ImmutableSet.create(iterable);
+}

package/lib-commonjs/utils/createOpenItems.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createOpenItems.js"],"sourcesContent":["import { ImmutableSet } from './ImmutableSet';\nexport function createOpenItems(iterable) {\n    if (iterable === undefined) {\n        return ImmutableSet.empty;\n    }\n    if (ImmutableSet.isImmutableSet(iterable)) {\n        return iterable;\n    }\n    return ImmutableSet.create(iterable);\n}\n"],"names":["createOpenItems","iterable","undefined","ImmutableSet","empty","isImmutableSet","create"],"mappings":";;;;+BACgBA;;aAAAA;;8BADa;AACtB,SAASA,gBAAgBC,QAAQ,EAAE;IACtC,IAAIA,aAAaC,WAAW;QACxB,OAAOC,0BAAY,CAACC,KAAK;IAC7B,CAAC;IACD,IAAID,0BAAY,CAACE,cAAc,CAACJ,WAAW;QACvC,OAAOA;IACX,CAAC;IACD,OAAOE,0BAAY,CAACG,MAAM,CAACL;AAC/B"}