@malloy-publisher/sdk 0.0.89 → 0.0.90

package/dist/client/index.es445.js

@@ -0,0 +1,56 @@
+import a from "./index.es408.js";
+import u from "./index.es409.js";
+import * as p from "react";
+import { jsx as n } from "react/jsx-runtime";
+import { TreeItem as f } from "./index.es537.js";
+import P from "./index.es447.js";
+const h = ["ownerState"];
+function I({
+  slots: o,
+  slotProps: t,
+  label: r,
+  id: s,
+  itemId: e,
+  itemsToRender: i
+}) {
+  const m = o?.item ?? f, l = P({
+    elementType: m,
+    externalSlotProps: t?.item,
+    additionalProps: {
+      itemId: e,
+      id: s,
+      label: r
+    },
+    ownerState: {
+      itemId: e,
+      label: r
+    }
+  }), c = u(l, h), d = p.useMemo(() => i ? /* @__PURE__ */ n(x, {
+    itemsToRender: i,
+    slots: o,
+    slotProps: t
+  }) : null, [i, o, t]);
+  return /* @__PURE__ */ n(m, a({}, c, {
+    children: d
+  }));
+}
+function x(o) {
+  const {
+    itemsToRender: t,
+    slots: r,
+    slotProps: s
+  } = o;
+  return /* @__PURE__ */ n(p.Fragment, {
+    children: t.map((e) => /* @__PURE__ */ n(I, {
+      slots: r,
+      slotProps: s,
+      label: e.label,
+      id: e.id,
+      itemId: e.itemId,
+      itemsToRender: e.children
+    }, e.itemId))
+  });
+}
+export {
+  x as RichTreeViewItems
+};

package/dist/client/index.es446.js

@@ -0,0 +1,71 @@
+import j from "./index.es408.js";
+import * as n from "react";
+import { useTreeViewModels as w } from "./index.es576.js";
+import { extractPluginParamsFromProps as S } from "./index.es577.js";
+import { useTreeViewBuildContext as T } from "./index.es578.js";
+import { TREE_VIEW_CORE_PLUGINS as h } from "./index.es579.js";
+import _ from "./index.es465.js";
+function F(o) {
+  const c = n.useRef({});
+  return o ? (o.current == null && (o.current = {}), o.current) : c.current;
+}
+const N = ({
+  plugins: o,
+  rootRef: c,
+  props: m
+}) => {
+  const r = [...h, ...o], {
+    pluginParams: i,
+    forwardedProps: R,
+    apiRef: P,
+    experimentalFeatures: g,
+    slots: b,
+    slotProps: x
+  } = S({
+    plugins: r,
+    props: m
+  }), I = w(r, i), s = n.useRef({}).current, u = F(P), a = n.useRef(null), f = _(a, c), l = T({
+    plugins: r,
+    instance: s,
+    publicAPI: u,
+    rootRef: a
+  }), [V, E] = n.useState(() => {
+    const e = {};
+    return r.forEach((t) => {
+      t.getInitialState && Object.assign(e, t.getInitialState(i));
+    }), e;
+  }), p = [], d = (e) => {
+    const t = e({
+      instance: s,
+      params: i,
+      slots: b,
+      slotProps: x,
+      experimentalFeatures: g,
+      state: V,
+      setState: E,
+      rootRef: a,
+      models: I,
+      plugins: r
+    });
+    t.getRootProps && p.push(t.getRootProps), t.publicAPI && Object.assign(u, t.publicAPI), t.instance && Object.assign(s, t.instance), t.contextValue && Object.assign(l, t.contextValue);
+  };
+  return r.forEach(d), {
+    getRootProps: (e = {}) => {
+      const t = j({
+        role: "tree"
+      }, R, e, {
+        ref: f
+      });
+      return p.forEach((O) => {
+        Object.assign(t, O(e));
+      }), t;
+    },
+    rootRef: f,
+    contextValue: l,
+    instance: s
+  };
+};
+export {
+  N as useTreeView,
+  F as useTreeViewApiInitialization
+};

package/dist/client/index.es447.js

@@ -0,0 +1,26 @@
+import i from "./index.es470.js";
+import a from "./index.es574.js";
+import P from "./index.es465.js";
+import S from "./index.es575.js";
+function x(o) {
+  const {
+    elementType: t,
+    externalSlotProps: p,
+    ownerState: e,
+    skipResolvingSlotProps: s = !1,
+    ...n
+  } = o, r = s ? {} : i(p, e), {
+    props: l,
+    internalRef: f
+  } = a({
+    ...n,
+    externalSlotProps: r
+  }), m = P(f, r?.ref, o.additionalProps?.ref);
+  return S(t, {
+    ...l,
+    ref: m
+  }, e);
+}
+export {
+  x as default
+};

package/dist/client/index.es448.js

@@ -0,0 +1,19 @@
+import "react";
+import { TreeViewContext as i } from "./index.es569.js";
+import { jsx as t } from "react/jsx-runtime";
+function m(r) {
+  const {
+    value: e,
+    children: o
+  } = r;
+  return /* @__PURE__ */ t(i.Provider, {
+    value: e,
+    children: e.wrapRoot({
+      children: o,
+      instance: e.instance
+    })
+  });
+}
+export {
+  m as TreeViewProvider
+};

package/dist/client/index.es449.js

@@ -0,0 +1,16 @@
+function s(f, a, e = void 0) {
+  const u = {};
+  for (const r in f) {
+    const l = f[r];
+    let o = "", i = !0;
+    for (let n = 0; n < l.length; n += 1) {
+      const t = l[n];
+      t && (o += (i === !0 ? "" : " ") + a(t), i = !1, e && e[t] && (o += " " + e[t]));
+    }
+    u[r] = o;
+  }
+  return u;
+}
+export {
+  s as default
+};

package/dist/client/index.es45.js

@@ -0,0 +1,8 @@
+import { jsx as o } from "react/jsx-runtime";
+import t from "./index.es58.js";
+const v = t(/* @__PURE__ */ o("path", {
+  d: "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6z"
+}));
+export {
+  v as default
+};

package/dist/client/index.es450.js

@@ -0,0 +1,23 @@
+import s from "./index.es478.js";
+const t = {
+  active: "active",
+  checked: "checked",
+  completed: "completed",
+  disabled: "disabled",
+  error: "error",
+  expanded: "expanded",
+  focused: "focused",
+  focusVisible: "focusVisible",
+  open: "open",
+  readOnly: "readOnly",
+  required: "required",
+  selected: "selected"
+};
+function o(d, e, r = "Mui") {
+  const a = t[e];
+  return a ? `${r}-${a}` : `${s.generate(d)}-${e}`;
+}
+export {
+  o as default,
+  t as globalStateClasses
+};

package/dist/client/index.es451.js

@@ -0,0 +1,10 @@
+import s from "./index.es450.js";
+function l(r, a, i = "Mui") {
+  const t = {};
+  return a.forEach((e) => {
+    t[e] = s(r, e, i);
+  }), t;
+}
+export {
+  l as default
+};

package/dist/client/index.es452.js

@@ -0,0 +1,182 @@
+import T from "./index.es408.js";
+import E from "./index.es409.js";
+import * as m from "react";
+import { publishTreeViewEvent as x } from "./index.es561.js";
+import { TREE_VIEW_ROOT_PARENT_ID as I, buildSiblingIndexes as A } from "./index.es562.js";
+import { generateTreeItemIdAttribute as k } from "./index.es462.js";
+import { jsx as D } from "react/jsx-runtime";
+import { TreeViewItemDepthContext as P } from "./index.es463.js";
+const R = ["children"], O = ({
+  items: t,
+  isItemDisabled: n,
+  getItemLabel: i,
+  getItemId: a
+}) => {
+  const u = {}, g = {}, o = {
+    [I]: []
+  }, c = (d, h, b) => {
+    const l = a ? a(d) : d.id;
+    if (l == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", "An item was provided without id in the `items` prop:", JSON.stringify(d)].join(`
+`));
+    if (u[l] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${l}"`].join(`
+`));
+    const p = i ? i(d) : d.label;
+    if (p == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a `label` property.", "Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.", "An item was provided without label in the `items` prop:", JSON.stringify(d)].join(`
+`));
+    u[l] = {
+      id: l,
+      label: p,
+      parentId: b,
+      idAttribute: void 0,
+      expandable: !!d.children?.length,
+      disabled: n ? n(d) : !1,
+      depth: h
+    }, g[l] = d;
+    const f = b ?? I;
+    o[f] || (o[f] = []), o[f].push(l), d.children?.forEach((w) => c(w, h + 1, l));
+  };
+  t.forEach((d) => c(d, 0, null));
+  const C = {};
+  return Object.keys(o).forEach((d) => {
+    C[d] = A(o[d]);
+  }), {
+    itemMetaMap: u,
+    itemMap: g,
+    itemOrderedChildrenIds: o,
+    itemChildrenIndexes: C
+  };
+}, M = ({
+  instance: t,
+  params: n,
+  state: i,
+  setState: a,
+  experimentalFeatures: u
+}) => {
+  const g = m.useCallback((e) => i.items.itemMetaMap[e], [i.items.itemMetaMap]), o = m.useCallback((e) => i.items.itemMap[e], [i.items.itemMap]), c = m.useCallback(() => {
+    const e = (r) => {
+      const s = i.items.itemMap[r], v = E(s, R), y = i.items.itemOrderedChildrenIds[r];
+      return y && (v.children = y.map(e)), v;
+    };
+    return i.items.itemOrderedChildrenIds[I].map(e);
+  }, [i.items.itemMap, i.items.itemOrderedChildrenIds]), C = m.useCallback((e) => {
+    if (e == null)
+      return !1;
+    let r = t.getItemMeta(e);
+    if (!r)
+      return !1;
+    if (r.disabled)
+      return !0;
+    for (; r.parentId != null; )
+      if (r = t.getItemMeta(r.parentId), r.disabled)
+        return !0;
+    return !1;
+  }, [t]), d = m.useCallback((e) => {
+    const r = t.getItemMeta(e).parentId ?? I;
+    return i.items.itemChildrenIndexes[r][e];
+  }, [t, i.items.itemChildrenIndexes]), h = m.useCallback((e) => i.items.itemOrderedChildrenIds[e ?? I] ?? [], [i.items.itemOrderedChildrenIds]), b = (e) => {
+    const r = t.getItemMeta(e);
+    return r == null ? null : document.getElementById(k({
+      treeId: i.id.treeId,
+      itemId: e,
+      id: r.idAttribute
+    }));
+  }, l = (e) => n.disabledItemsFocusable ? !0 : !t.isItemDisabled(e), p = m.useRef(!1), f = m.useCallback(() => {
+    p.current = !0;
+  }, []), w = m.useCallback(() => p.current, []);
+  return m.useEffect(() => {
+    t.areItemUpdatesPrevented() || a((e) => {
+      const r = O({
+        items: n.items,
+        isItemDisabled: n.isItemDisabled,
+        getItemId: n.getItemId,
+        getItemLabel: n.getItemLabel
+      });
+      return Object.values(e.items.itemMetaMap).forEach((s) => {
+        r.itemMetaMap[s.id] || x(t, "removeItem", {
+          id: s.id
+        });
+      }), T({}, e, {
+        items: r
+      });
+    });
+  }, [t, a, n.items, n.isItemDisabled, n.getItemId, n.getItemLabel]), {
+    getRootProps: () => ({
+      style: {
+        "--TreeView-itemChildrenIndentation": typeof n.itemChildrenIndentation == "number" ? `${n.itemChildrenIndentation}px` : n.itemChildrenIndentation
+      }
+    }),
+    publicAPI: {
+      getItem: o,
+      getItemDOMElement: b,
+      getItemTree: c,
+      getItemOrderedChildrenIds: h
+    },
+    instance: {
+      getItemMeta: g,
+      getItem: o,
+      getItemTree: c,
+      getItemsToRender: () => {
+        const e = (r) => {
+          const s = i.items.itemMetaMap[r];
+          return {
+            label: s.label,
+            itemId: s.id,
+            id: s.idAttribute,
+            children: i.items.itemOrderedChildrenIds[r]?.map(e)
+          };
+        };
+        return i.items.itemOrderedChildrenIds[I].map(e);
+      },
+      getItemIndex: d,
+      getItemDOMElement: b,
+      getItemOrderedChildrenIds: h,
+      isItemDisabled: C,
+      isItemNavigable: l,
+      preventItemUpdates: f,
+      areItemUpdatesPrevented: w
+    },
+    contextValue: {
+      items: {
+        onItemClick: n.onItemClick,
+        disabledItemsFocusable: n.disabledItemsFocusable,
+        indentationAtItemLevel: u.indentationAtItemLevel ?? !1
+      }
+    }
+  };
+};
+M.getInitialState = (t) => ({
+  items: O({
+    items: t.items,
+    isItemDisabled: t.isItemDisabled,
+    getItemId: t.getItemId,
+    getItemLabel: t.getItemLabel
+  })
+});
+M.getDefaultizedParams = ({
+  params: t
+}) => T({}, t, {
+  disabledItemsFocusable: t.disabledItemsFocusable ?? !1,
+  itemChildrenIndentation: t.itemChildrenIndentation ?? "12px"
+});
+M.wrapRoot = ({
+  children: t,
+  instance: n
+}) => /* @__PURE__ */ D(P.Provider, {
+  value: (i) => n.getItemMeta(i)?.depth ?? 0,
+  children: t
+});
+M.params = {
+  disabledItemsFocusable: !0,
+  items: !0,
+  isItemDisabled: !0,
+  getItemLabel: !0,
+  getItemId: !0,
+  onItemClick: !0,
+  itemChildrenIndentation: !0
+};
+export {
+  M as useTreeViewItems
+};

package/dist/client/index.es453.js

@@ -0,0 +1,68 @@
+import C from "./index.es408.js";
+import * as i from "react";
+import u from "./index.es534.js";
+const p = ({
+  instance: e,
+  params: o,
+  models: d
+}) => {
+  const l = i.useMemo(() => {
+    const t = /* @__PURE__ */ new Map();
+    return d.expandedItems.value.forEach((n) => {
+      t.set(n, !0);
+    }), t;
+  }, [d.expandedItems.value]), E = (t, n) => {
+    o.onExpandedItemsChange?.(t, n), d.expandedItems.setControlledValue(n);
+  }, I = i.useCallback((t) => l.has(t), [l]), m = i.useCallback((t) => !!e.getItemMeta(t)?.expandable, [e]), f = u((t, n) => {
+    const a = e.isItemExpanded(n);
+    e.setItemExpansion(t, n, !a);
+  }), g = u((t, n, a) => {
+    if (e.isItemExpanded(n) === a)
+      return;
+    let s;
+    a ? s = [n].concat(d.expandedItems.value) : s = d.expandedItems.value.filter((x) => x !== n), o.onItemExpansionToggle && o.onItemExpansionToggle(t, n, a), E(t, s);
+  }), c = (t, n) => {
+    const a = e.getItemMeta(n), s = e.getItemOrderedChildrenIds(a.parentId).filter((r) => e.isItemExpandable(r) && !e.isItemExpanded(r)), x = d.expandedItems.value.concat(s);
+    s.length > 0 && (o.onItemExpansionToggle && s.forEach((r) => {
+      o.onItemExpansionToggle(t, r, !0);
+    }), E(t, x));
+  }, T = i.useMemo(() => o.expansionTrigger ? o.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [o.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: g
+    },
+    instance: {
+      isItemExpanded: I,
+      isItemExpandable: m,
+      setItemExpansion: g,
+      toggleItemExpansion: f,
+      expandAllSiblings: c
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: T
+      }
+    }
+  };
+};
+p.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const M = [];
+p.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? M
+});
+p.params = {
+  expandedItems: !0,
+  defaultExpandedItems: !0,
+  onExpandedItemsChange: !0,
+  onItemExpansionToggle: !0,
+  expansionTrigger: !0
+};
+export {
+  p as useTreeViewExpansion
+};

package/dist/client/index.es454.js

@@ -0,0 +1,121 @@
+import h from "./index.es408.js";
+import * as d from "react";
+import { getLastNavigableItem as E, getFirstNavigableItem as k, findOrderInTremauxTree as F, getAllNavigableItems as N, getNonDisabledItemsInRange as x } from "./index.es461.js";
+import { convertSelectedItemsToArray as m, getLookupFromArray as b } from "./index.es560.js";
+const T = ({
+  instance: n,
+  params: c,
+  models: s
+}) => {
+  const g = d.useRef(null), u = d.useRef({}), R = d.useMemo(() => {
+    const t = /* @__PURE__ */ new Map();
+    return Array.isArray(s.selectedItems.value) ? s.selectedItems.value.forEach((e) => {
+      t.set(e, !0);
+    }) : s.selectedItems.value != null && t.set(s.selectedItems.value, !0), t;
+  }, [s.selectedItems.value]), S = (t, e) => {
+    if (c.onItemSelectionToggle)
+      if (c.multiSelect) {
+        const i = e.filter((o) => !n.isItemSelected(o)), l = s.selectedItems.value.filter((o) => !e.includes(o));
+        i.forEach((o) => {
+          c.onItemSelectionToggle(t, o, !0);
+        }), l.forEach((o) => {
+          c.onItemSelectionToggle(t, o, !1);
+        });
+      } else e !== s.selectedItems.value && (s.selectedItems.value != null && c.onItemSelectionToggle(t, s.selectedItems.value, !1), e != null && c.onItemSelectionToggle(t, e, !0));
+    c.onSelectedItemsChange && c.onSelectedItemsChange(t, e), s.selectedItems.setControlledValue(e);
+  }, A = (t) => R.has(t), v = ({
+    event: t,
+    itemId: e,
+    keepExistingSelection: i = !1,
+    shouldBeSelected: l
+  }) => {
+    if (c.disableSelection)
+      return;
+    let o;
+    if (i) {
+      const r = m(s.selectedItems.value), a = n.isItemSelected(e);
+      a && (l === !1 || l == null) ? o = r.filter((f) => f !== e) : !a && (l === !0 || l == null) ? o = [e].concat(r) : o = r;
+    } else
+      l === !1 || l == null && n.isItemSelected(e) ? o = c.multiSelect ? [] : null : o = c.multiSelect ? [e] : e;
+    S(t, o), g.current = e, u.current = {};
+  }, I = (t, [e, i]) => {
+    if (c.disableSelection || !c.multiSelect)
+      return;
+    let l = m(s.selectedItems.value).slice();
+    Object.keys(u.current).length > 0 && (l = l.filter((f) => !u.current[f]));
+    const o = b(l), r = x(n, e, i), a = r.filter((f) => !o[f]);
+    l = l.concat(a), S(t, l), u.current = b(r);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": c.multiSelect
+    }),
+    publicAPI: {
+      selectItem: v
+    },
+    instance: {
+      isItemSelected: A,
+      selectItem: v,
+      selectAllNavigableItems: (t) => {
+        if (c.disableSelection || !c.multiSelect)
+          return;
+        const e = N(n);
+        S(t, e), u.current = b(e);
+      },
+      expandSelectionRange: (t, e) => {
+        if (g.current != null) {
+          const [i, l] = F(n, e, g.current);
+          I(t, [i, l]);
+        }
+      },
+      selectRangeFromStartToItem: (t, e) => {
+        I(t, [k(n), e]);
+      },
+      selectRangeFromItemToEnd: (t, e) => {
+        I(t, [e, E(n)]);
+      },
+      selectItemFromArrowNavigation: (t, e, i) => {
+        if (c.disableSelection || !c.multiSelect)
+          return;
+        let l = m(s.selectedItems.value).slice();
+        Object.keys(u.current).length === 0 ? (l.push(i), u.current = {
+          [e]: !0,
+          [i]: !0
+        }) : (u.current[e] || (u.current = {}), u.current[i] ? (l = l.filter((o) => o !== e), delete u.current[e]) : (l.push(i), u.current[i] = !0)), S(t, l);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: c.multiSelect,
+        checkboxSelection: c.checkboxSelection,
+        disableSelection: c.disableSelection
+      }
+    }
+  };
+};
+T.models = {
+  selectedItems: {
+    getDefaultValue: (n) => n.defaultSelectedItems
+  }
+};
+const y = [];
+T.getDefaultizedParams = ({
+  params: n
+}) => h({}, n, {
+  disableSelection: n.disableSelection ?? !1,
+  multiSelect: n.multiSelect ?? !1,
+  checkboxSelection: n.checkboxSelection ?? !1,
+  defaultSelectedItems: n.defaultSelectedItems ?? (n.multiSelect ? y : null)
+});
+T.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+export {
+  T as useTreeViewSelection
+};

package/dist/client/index.es455.js

@@ -0,0 +1,78 @@
+import T from "./index.es408.js";
+import * as p from "react";
+import { useInstanceEventHandler as x } from "./index.es563.js";
+import { getActiveElement as D } from "./index.es564.js";
+import { getFirstNavigableItem as k } from "./index.es461.js";
+import { convertSelectedItemsToArray as w } from "./index.es560.js";
+import d from "./index.es534.js";
+import A from "./index.es565.js";
+const C = (o, r) => {
+  let m = w(r).find((c) => {
+    if (!o.isItemNavigable(c))
+      return !1;
+    const u = o.getItemMeta(c);
+    return u && (u.parentId == null || o.isItemExpanded(u.parentId));
+  });
+  return m == null && (m = k(o)), m;
+}, b = ({
+  instance: o,
+  params: r,
+  state: m,
+  setState: c,
+  models: u,
+  rootRef: n
+}) => {
+  const I = C(o, u.selectedItems.value), f = d((t) => {
+    const e = typeof t == "function" ? t(m.focusedItemId) : t;
+    m.focusedItemId !== e && c((s) => T({}, s, {
+      focusedItemId: e
+    }));
+  }), i = p.useCallback(() => !!n.current && n.current.contains(D(A(n.current))), [n]), F = p.useCallback((t) => m.focusedItemId === t && i(), [m.focusedItemId, i]), g = (t) => {
+    const e = o.getItemMeta(t);
+    return e && (e.parentId == null || o.isItemExpanded(e.parentId));
+  }, l = (t, e) => {
+    const s = o.getItemDOMElement(e);
+    s && s.focus(), f(e), r.onItemFocus && r.onItemFocus(t, e);
+  }, a = d((t, e) => {
+    g(e) && l(t, e);
+  }), M = d(() => {
+    if (m.focusedItemId == null)
+      return;
+    if (o.getItemMeta(m.focusedItemId)) {
+      const e = o.getItemDOMElement(m.focusedItemId);
+      e && e.blur();
+    }
+    f(null);
+  }), E = (t) => t === I;
+  x(o, "removeItem", ({
+    id: t
+  }) => {
+    m.focusedItemId === t && l(null, I);
+  });
+  const v = (t) => (e) => {
+    t.onFocus?.(e), !e.defaultMuiPrevented && e.target === e.currentTarget && l(e, I);
+  };
+  return {
+    getRootProps: (t) => ({
+      onFocus: v(t)
+    }),
+    publicAPI: {
+      focusItem: a
+    },
+    instance: {
+      isItemFocused: F,
+      canItemBeTabbed: E,
+      focusItem: a,
+      removeFocusedItem: M
+    }
+  };
+};
+b.getInitialState = () => ({
+  focusedItemId: null
+});
+b.params = {
+  onItemFocus: !0
+};
+export {
+  b as useTreeViewFocus
+};