Initial commit

node_modules/@fluentui/react-tree/lib-commonjs/contexts/index.js

@@ -0,0 +1,33 @@
+"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, {
+    SubtreeContext: function() {
+        return _subtreeContext.SubtreeContext;
+    },
+    TreeContext: function() {
+        return _treeContext.TreeContext;
+    },
+    TreeItemProvider: function() {
+        return _treeItemContext.TreeItemProvider;
+    },
+    useSubtreeContext_unstable: function() {
+        return _subtreeContext.useSubtreeContext_unstable;
+    },
+    useTreeContext_unstable: function() {
+        return _treeContext.useTreeContext_unstable;
+    },
+    useTreeItemContext_unstable: function() {
+        return _treeItemContext.useTreeItemContext_unstable;
+    }
+});
+const _treeContext = require("./treeContext");
+const _subtreeContext = require("./subtreeContext");
+const _treeItemContext = require("./treeItemContext");

node_modules/@fluentui/react-tree/lib-commonjs/contexts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/index.ts"],"sourcesContent":["export type { TreeContextValue, TreeItemRequest } from './treeContext';\nexport { TreeContext, useTreeContext_unstable } from './treeContext';\nexport type { SubtreeContextValue } from './subtreeContext';\nexport { SubtreeContext, useSubtreeContext_unstable } from './subtreeContext';\nexport type { TreeItemContextValue } from './treeItemContext';\nexport { TreeItemProvider, useTreeItemContext_unstable } from './treeItemContext';\n"],"names":["SubtreeContext","TreeContext","TreeItemProvider","useSubtreeContext_unstable","useTreeContext_unstable","useTreeItemContext_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAGSA,cAAc;eAAdA,8BAAc;;IAFdC,WAAW;eAAXA,wBAAW;;IAIXC,gBAAgB;eAAhBA,iCAAgB;;IAFAC,0BAA0B;eAA1BA,0CAA0B;;IAF7BC,uBAAuB;eAAvBA,oCAAuB;;IAIlBC,2BAA2B;eAA3BA,4CAA2B;;;6BAJD;gCAEM;iCAEG"}

node_modules/@fluentui/react-tree/lib-commonjs/contexts/subtreeContext.js

@@ -0,0 +1,31 @@
+"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, {
+    SubtreeContext: function() {
+        return SubtreeContext;
+    },
+    useSubtreeContext_unstable: function() {
+        return useSubtreeContext_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+/**
+ * @internal
+ */ const defaultSubTreeContextValue = {
+    level: 0,
+    contextType: 'subtree'
+};
+const SubtreeContext = /*#__PURE__*/ _react.createContext(undefined);
+const useSubtreeContext_unstable = ()=>{
+    var _React_useContext;
+    return (_React_useContext = _react.useContext(SubtreeContext)) !== null && _React_useContext !== void 0 ? _React_useContext : defaultSubTreeContextValue;
+};

node_modules/@fluentui/react-tree/lib-commonjs/contexts/subtreeContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/subtreeContext.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type SubtreeContextValue = {\n  contextType: 'subtree';\n  level: number;\n};\n\n/**\n * @internal\n */\nconst defaultSubTreeContextValue: SubtreeContextValue = {\n  level: 0,\n  contextType: 'subtree',\n};\n\n/**\n * @internal\n */\nexport const SubtreeContext: React.Context<SubtreeContextValue> = React.createContext<SubtreeContextValue | undefined>(\n  undefined,\n) as React.Context<SubtreeContextValue>;\n\nexport const useSubtreeContext_unstable = () => {\n  return React.useContext(SubtreeContext) ?? defaultSubTreeContextValue;\n};\n"],"names":["SubtreeContext","useSubtreeContext_unstable","defaultSubTreeContextValue","level","contextType","React","createContext","undefined","useContext"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAkBaA,cAAAA;eAAAA;;IAIAC,0BAAAA;eAAAA;;;;iEAtBU;AAOvB;;CAEC,GACD,MAAMC,6BAAkD;IACtDC,OAAO;IACPC,aAAa;AACf;AAKO,MAAMJ,+BAAqDK,OAAMC,aAAa,CACnFC;AAGK,MAAMN,6BAA6B;QACjCI;IAAP,OAAOA,CAAAA,oBAAAA,OAAMG,UAAU,CAACR,eAAAA,MAAAA,QAAjBK,sBAAAA,KAAAA,IAAAA,oBAAoCH;AAC7C"}

node_modules/@fluentui/react-tree/lib-commonjs/contexts/treeContext.js

@@ -0,0 +1,40 @@
+"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, {
+    TreeContext: function() {
+        return TreeContext;
+    },
+    useTreeContext_unstable: function() {
+        return useTreeContext_unstable;
+    }
+});
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const _ImmutableSet = require("../utils/ImmutableSet");
+const _ImmutableMap = require("../utils/ImmutableMap");
+/**
+ * @internal
+ */ const defaultTreeContextValue = {
+    level: 0,
+    contextType: 'root',
+    treeType: 'nested',
+    selectionMode: 'none',
+    openItems: _ImmutableSet.ImmutableSet.empty,
+    checkedItems: _ImmutableMap.ImmutableMap.empty,
+    requestTreeResponse: noop,
+    forceUpdateRovingTabIndex: noop,
+    appearance: 'subtle',
+    size: 'medium',
+    navigationMode: 'tree'
+};
+function noop() {
+/* noop */ }
+const TreeContext = (0, _reactcontextselector.createContext)(undefined);
+const useTreeContext_unstable = (selector)=>(0, _reactcontextselector.useContextSelector)(TreeContext, (ctx = defaultTreeContextValue)=>selector(ctx));

node_modules/@fluentui/react-tree/lib-commonjs/contexts/treeContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/treeContext.ts"],"sourcesContent":["import { Context, ContextSelector, createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport { TreeItemType, TreeItemValue } from '../TreeItem';\nimport type { SelectionMode, DistributiveOmit } from '@fluentui/react-utilities';\nimport { ImmutableSet } from '../utils/ImmutableSet';\nimport { ImmutableMap } from '../utils/ImmutableMap';\nimport { TreeCheckedChangeData, TreeNavigationData_unstable, TreeOpenChangeData } from '../Tree';\n\nexport type TreeContextValue = {\n  contextType?: 'root';\n  level: number;\n  treeType: 'nested' | 'flat';\n  selectionMode: 'none' | SelectionMode;\n  appearance: 'subtle' | 'subtle-alpha' | 'transparent';\n  size: 'small' | 'medium';\n  openItems: ImmutableSet<TreeItemValue>;\n  checkedItems: ImmutableMap<TreeItemValue, 'mixed' | boolean>;\n  /**\n   * requests root Tree component to respond to some tree item event,\n   */\n  requestTreeResponse(request: TreeItemRequest): void;\n  // FIXME: this is only marked as optional to avoid breaking changes\n  // it should always be provided internally\n  forceUpdateRovingTabIndex?(): void;\n  // FIXME: this is only marked as optional to avoid breaking changes\n  // it should always be provided internally\n  navigationMode?: 'tree' | 'treegrid';\n};\n\nexport type TreeItemRequest = { itemType: TreeItemType } & (\n  | (DistributiveOmit<TreeOpenChangeData, 'openItems'> & { requestType: 'open' })\n  | (TreeNavigationData_unstable & { requestType: 'navigate' })\n  | (DistributiveOmit<TreeCheckedChangeData, 'selectionMode' | 'checkedItems'> & { requestType: 'selection' })\n);\n\n/**\n * @internal\n */\nconst defaultTreeContextValue: TreeContextValue = {\n  level: 0,\n  contextType: 'root',\n  treeType: 'nested',\n  selectionMode: 'none',\n  openItems: ImmutableSet.empty,\n  checkedItems: ImmutableMap.empty,\n  requestTreeResponse: noop,\n  forceUpdateRovingTabIndex: noop,\n  appearance: 'subtle',\n  size: 'medium',\n  navigationMode: 'tree',\n};\n\nfunction noop() {\n  /* noop */\n}\n\n/**\n * @internal\n */\nexport const TreeContext: Context<TreeContextValue> = createContext<TreeContextValue | undefined>(\n  undefined,\n) as Context<TreeContextValue>;\n\nexport const useTreeContext_unstable = <T>(selector: ContextSelector<TreeContextValue, T>): T =>\n  useContextSelector(TreeContext, (ctx = defaultTreeContextValue) => selector(ctx));\n"],"names":["TreeContext","useTreeContext_unstable","defaultTreeContextValue","level","contextType","treeType","selectionMode","openItems","ImmutableSet","empty","checkedItems","ImmutableMap","requestTreeResponse","noop","forceUpdateRovingTabIndex","appearance","size","navigationMode","createContext","undefined","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA0DaA,WAAAA;eAAAA;;IAIAC,uBAAAA;eAAAA;;;sCA9D+D;8BAG/C;8BACA;AA8B7B;;CAEC,GACD,MAAMC,0BAA4C;IAChDC,OAAO;IACPC,aAAa;IACbC,UAAU;IACVC,eAAe;IACfC,WAAWC,0BAAAA,CAAaC,KAAK;IAC7BC,cAAcC,0BAAAA,CAAaF,KAAK;IAChCG,qBAAqBC;IACrBC,2BAA2BD;IAC3BE,YAAY;IACZC,MAAM;IACNC,gBAAgB;AAClB;AAEA,SAASJ;AACP,QAAQ,GACV;AAKO,MAAMb,cAAyCkB,IAAAA,mCAAAA,EACpDC;AAGK,MAAMlB,0BAA0B,CAAImB,WACzCC,IAAAA,wCAAAA,EAAmBrB,aAAa,CAACsB,MAAMpB,uBAAuB,GAAKkB,SAASE"}

node_modules/@fluentui/react-tree/lib-commonjs/contexts/treeItemContext.js

@@ -0,0 +1,39 @@
+"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, {
+    TreeItemProvider: function() {
+        return TreeItemProvider;
+    },
+    useTreeItemContext_unstable: function() {
+        return useTreeItemContext_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const _createHeadlessTree = require("../utils/createHeadlessTree");
+const defaultContextValue = {
+    value: _createHeadlessTree.headlessTreeRootId,
+    selectionRef: /*#__PURE__*/ _react.createRef(),
+    layoutRef: /*#__PURE__*/ _react.createRef(),
+    treeItemRef: /*#__PURE__*/ _react.createRef(),
+    subtreeRef: /*#__PURE__*/ _react.createRef(),
+    actionsRef: /*#__PURE__*/ _react.createRef(),
+    expandIconRef: /*#__PURE__*/ _react.createRef(),
+    isActionsVisible: false,
+    isAsideVisible: false,
+    itemType: 'leaf',
+    open: false,
+    checked: false
+};
+const TreeItemContext = (0, _reactcontextselector.createContext)(undefined);
+const { Provider: TreeItemProvider } = TreeItemContext;
+const useTreeItemContext_unstable = (selector)=>(0, _reactcontextselector.useContextSelector)(TreeItemContext, (ctx = defaultContextValue)=>selector(ctx));

node_modules/@fluentui/react-tree/lib-commonjs/contexts/treeItemContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contexts/treeItemContext.ts"],"sourcesContent":["import * as React from 'react';\nimport { Context, ContextSelector, createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport type { TreeItemType, TreeItemValue } from '../TreeItem';\nimport { headlessTreeRootId } from '../utils/createHeadlessTree';\nimport { TreeSelectionValue } from '../Tree';\n\nexport type TreeItemContextValue = {\n  /**\n   * @deprecated - this value is irrelevant for the tree item\n   */\n  isActionsVisible: boolean;\n  /**\n   * @deprecated - this value is irrelevant for the tree item\n   */\n  isAsideVisible: boolean;\n  selectionRef: React.Ref<HTMLInputElement>;\n  actionsRef: React.Ref<HTMLDivElement>;\n  expandIconRef: React.Ref<HTMLDivElement>;\n  layoutRef: React.Ref<HTMLDivElement>;\n  // FIXME: this should be React.RefObject<HTMLDivElement>,\n  //  but as it would be a breaking change, we need to keep it as is for now\n  subtreeRef: React.Ref<HTMLDivElement>;\n  // FIXME: this is only marked as optional to avoid breaking changes\n  // it should always be provided internally\n  treeItemRef?: React.RefObject<HTMLDivElement>;\n  itemType: TreeItemType;\n  value: TreeItemValue;\n  open: boolean;\n  checked: TreeSelectionValue;\n};\n\nconst defaultContextValue: TreeItemContextValue = {\n  value: headlessTreeRootId,\n  selectionRef: React.createRef(),\n  layoutRef: React.createRef(),\n  treeItemRef: React.createRef(),\n  subtreeRef: React.createRef(),\n  actionsRef: React.createRef(),\n  expandIconRef: React.createRef(),\n  isActionsVisible: false,\n  isAsideVisible: false,\n  itemType: 'leaf',\n  open: false,\n  checked: false,\n};\n\nconst TreeItemContext: Context<TreeItemContextValue | undefined> = createContext<TreeItemContextValue | undefined>(\n  undefined,\n);\n\nexport const { Provider: TreeItemProvider } = TreeItemContext;\nexport const useTreeItemContext_unstable = <T>(selector: ContextSelector<TreeItemContextValue, T>): T =>\n  useContextSelector(TreeItemContext, (ctx = defaultContextValue) => selector(ctx));\n"],"names":["TreeItemProvider","useTreeItemContext_unstable","defaultContextValue","value","headlessTreeRootId","selectionRef","React","createRef","layoutRef","treeItemRef","subtreeRef","actionsRef","expandIconRef","isActionsVisible","isAsideVisible","itemType","open","checked","TreeItemContext","createContext","undefined","Provider","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAkDyBA,gBAAgB;eAAhBA;;IACZC,2BAAAA;eAAAA;;;;iEAnDU;sCACqD;oCAEzC;AA4BnC,MAAMC,sBAA4C;IAChDC,OAAOC,sCAAAA;IACPC,4BAAcC,OAAMC,SAAS;IAC7BC,yBAAWF,OAAMC,SAAS;IAC1BE,2BAAaH,OAAMC,SAAS;IAC5BG,0BAAYJ,OAAMC,SAAS;IAC3BI,0BAAYL,OAAMC,SAAS;IAC3BK,6BAAeN,OAAMC,SAAS;IAC9BM,kBAAkB;IAClBC,gBAAgB;IAChBC,UAAU;IACVC,MAAM;IACNC,SAAS;AACX;AAEA,MAAMC,kBAA6DC,IAAAA,mCAAAA,EACjEC;AAGK,MAAM,EAAEC,UAAUrB,gBAAgB,EAAE,GAAGkB;AACvC,MAAMjB,8BAA8B,CAAIqB,WAC7CC,IAAAA,wCAAAA,EAAmBL,iBAAiB,CAACM,MAAMtB,mBAAmB,GAAKoB,SAASE"}