@bccampus/ui-components 0.4.1 → 0.4.2

package/dist/AbstractFocusProvider-CxvlcEki.js

@@ -0,0 +1,29 @@
+import { a as o, C as i } from "./CompositeDataItem-DuHOHCWy.js";
+class f {
+  data;
+  dataOptions;
+  firstFocusableItem;
+  lastFocusableItem;
+  focusedItem = o(null);
+  init(t, s) {
+    this.data = t, this.dataOptions = s;
+    const [e, a] = this.setFocusPointers();
+    this.firstFocusableItem = e, this.firstFocusableItem && (this.firstFocusableItem.state.setKey("focused", !0), this.focusedItem.set(this.firstFocusableItem)), this.lastFocusableItem = a;
+  }
+  isFocusable(t) {
+    return !t.state.get().disabled;
+  }
+  focus(t) {
+    const s = t instanceof i ? t : this.data.lookup.get(t);
+    if (s) {
+      if (this.focusedItem.get()) {
+        if (s.key === this.focusedItem.get()?.key) return;
+        this.focusedItem.get().state.setKey("focused", !1);
+      }
+      s.state.setKey("focused", !0), this.focusedItem.set(s);
+    }
+  }
+}
+export {
+  f as A
+};

package/dist/AbstractSelectionProvider-BtaROstC.js

@@ -0,0 +1,30 @@
+import { a, C as n } from "./CompositeDataItem-DuHOHCWy.js";
+function c(o, e) {
+  const t = new Set(o);
+  for (const s of e)
+    t.add(s);
+  return t;
+}
+function d(o, e) {
+  const t = new Set(o);
+  for (const s of e)
+    t.delete(s);
+  return t;
+}
+class f {
+  data;
+  dataOptions;
+  selectedKeys = a(/* @__PURE__ */ new Set());
+  init(e, t) {
+    this.data = e, this.dataOptions = t, this.dataOptions.selectedKeys.forEach((s) => this.select(s));
+  }
+  toggleSelect(e, t = !1) {
+    const s = e ? e instanceof n ? e : this.data.lookup.get(e) : this.data.focusProvider.focusedItem.get();
+    s && (s.state.get().selected ? this.deselect(s, t) : this.select(s, t));
+  }
+}
+export {
+  f as A,
+  d,
+  c as u
+};

package/dist/CompositeDataItem-DuHOHCWy.js

@@ -0,0 +1,158 @@
+let p = Symbol("clean"), n = [], r = 0;
+const c = 4;
+let y = (a) => {
+  let t = [], e = {
+    get() {
+      return e.lc || e.listen(() => {
+      })(), e.value;
+    },
+    lc: 0,
+    listen(s) {
+      return e.lc = t.push(s), () => {
+        for (let i = r + c; i < n.length; )
+          n[i] === s ? n.splice(i, c) : i += c;
+        let l = t.indexOf(s);
+        ~l && (t.splice(l, 1), --e.lc || e.off());
+      };
+    },
+    notify(s, l) {
+      let i = !n.length;
+      for (let h of t)
+        n.push(h, e.value, s, l);
+      if (i) {
+        for (r = 0; r < n.length; r += c)
+          n[r](
+            n[r + 1],
+            n[r + 2],
+            n[r + 3]
+          );
+        n.length = 0;
+      }
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    off() {
+    },
+    set(s) {
+      let l = e.value;
+      l !== s && (e.value = s, e.notify(l));
+    },
+    subscribe(s) {
+      let l = e.listen(s);
+      return s(e.value), l;
+    },
+    value: a
+  };
+  return process.env.NODE_ENV !== "production" && (e[p] = () => {
+    t = [], e.lc = 0, e.off();
+  }), e;
+}, o = (a = {}) => {
+  let t = y(a);
+  return t.setKey = function(e, s) {
+    let l = t.value;
+    typeof s > "u" && e in t.value ? (t.value = { ...t.value }, delete t.value[e], t.notify(l, e)) : t.value[e] !== s && (t.value = {
+      ...t.value,
+      [e]: s
+    }, t.notify(l, e));
+  }, t;
+};
+const m = (a, t) => {
+  const e = { ...a };
+  return t.forEach((s) => {
+    const l = s.split("."), i = l.pop();
+    if (i) {
+      const h = l.reduce((d, f) => d && f in d ? d[f] : void 0, e);
+      h && i in h && delete h[i];
+    }
+  }), e;
+};
+class u {
+  #e;
+  parent = null;
+  children;
+  level;
+  data;
+  state;
+  pointers;
+  childrenProp;
+  constructor(t, e, s) {
+    this.#e = e.getItemKey(t), this.data = o(m(t, [e.itemChildrenProp])), this.state = o({
+      focused: !1,
+      selected: !1,
+      disabled: !1,
+      ...e.initialState
+    }), this.pointers = {}, this.parent = s, this.level = s ? s.level + 1 : 0, this.childrenProp = e.itemChildrenProp;
+    const l = e.getItemChildren(t);
+    l && (this.children = l.map((i) => new u(i, e, this)));
+  }
+  get key() {
+    return this.#e;
+  }
+  *[Symbol.iterator]() {
+    if (this.key !== "ALL" && (yield this), this.children)
+      for (const t of this.children)
+        for (const e of t) yield e;
+  }
+  toJSON() {
+    const t = { ...this.data.get() };
+    if (this.children) {
+      t[this.childrenProp] = [];
+      for (const e of this.children)
+        t[this.childrenProp].push(e.toJSON());
+    }
+    return t;
+  }
+  descendants() {
+    if (!this.children) return [];
+    const t = [];
+    return this.children.forEach(
+      (e) => {
+        t.push(e);
+        const s = e.descendants();
+        s && t.push(...s);
+      }
+    ), t;
+  }
+  ancestors() {
+    const t = [];
+    let e = this.parent;
+    for (; e; )
+      t.push(e), e = e.parent;
+    return t;
+  }
+  toggleSelect(t = !1) {
+    this.state.get().selected ? this.deselect(t) : this.select(t);
+  }
+  select(t = !1) {
+    if (this.state.setKey("selected", !0), t && this.children) {
+      const e = this.children.map((s) => s.select(!0)).flat();
+      return [this.key, ...e];
+    }
+    return [this.key];
+  }
+  deselect(t = !1) {
+    if (this.state.setKey("selected", !1), t && this.children) {
+      const e = this.children.map((s) => s.deselect(!0)).flat();
+      return [this.key, ...e];
+    }
+    return [this.key];
+  }
+  disable(t = !1) {
+    if (this.state.setKey("disabled", !0), t && this.children) {
+      const e = this.children.map((s) => s.disable(!0)).flat();
+      return [this.key, ...e];
+    }
+    return [this.key];
+  }
+  enable(t = !1) {
+    if (this.state.setKey("disabled", !1), t && this.children) {
+      const e = this.children.map((s) => s.enable(!0)).flat();
+      return [this.key, ...e];
+    }
+    return [this.key];
+  }
+}
+export {
+  u as C,
+  y as a
+};

package/dist/ListboxFocusProvider.d.ts

@@ -0,0 +1,149 @@
+import { PreinitializedMapStore } from 'nanostores';
+import { PreinitializedWritableAtom } from 'nanostores';
+
+declare abstract class AbstractFocusProvider<T extends object> implements FocusProvider {
+    protected data: CompositeData<T>;
+    protected dataOptions: CompositeDataOptions<T>;
+    firstFocusableItem: CompositeDataItem<T> | null;
+    lastFocusableItem: CompositeDataItem<T> | null;
+    focusedItem: PreinitializedWritableAtom<CompositeDataItem<T> | null>;
+    init(data: CompositeData<T>, dataOptions: CompositeDataOptions<T>): void;
+    isFocusable(itemAtom: CompositeDataItem<T>): boolean;
+    focus(itemKey: CompositeItemKey): void;
+    focus(item: CompositeDataItem<T>): void;
+    abstract setFocusPointers(): readonly [first: CompositeDataItem<T> | null, last: CompositeDataItem<T> | null];
+    abstract focusUp(): void;
+    abstract focusDown(): void;
+    abstract focusLeft(): void;
+    abstract focusRight(): void;
+    abstract focusPageUp(): void;
+    abstract focesPageDown(): void;
+    abstract focusToFirst(): void;
+    abstract focusToLast(): void;
+    abstract focusToFirstInRow(): void;
+    abstract focusToLastInRow(): void;
+    abstract focusToTypeAheadMatch(): void;
+}
+
+declare abstract class AbstractSelectionProvider<T extends object> {
+    protected data: CompositeData<T>;
+    protected dataOptions: CompositeDataOptions<T>;
+    selectedKeys: PreinitializedWritableAtom<Set<CompositeItemKey>>;
+    init(data: CompositeData<T>, dataOptions: CompositeDataOptions<T>): void;
+    abstract select(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    abstract select(item: CompositeDataItem<T>, recursive?: boolean): void;
+    abstract select(item?: CompositeDataItem<T> | CompositeItemKey, recursive?: boolean): void;
+    abstract deselect(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    abstract deselect(item: CompositeDataItem<T>, recursive?: boolean): void;
+    abstract deselect(item?: CompositeDataItem<T> | CompositeItemKey, recursive?: boolean): void;
+    toggleSelect(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    toggleSelect(item: CompositeDataItem<T>, recursive?: boolean): void;
+}
+
+declare class CompositeData<T extends object> implements Iterable<CompositeDataItem<T>> {
+    #private;
+    lookup: Map<CompositeItemKey, CompositeDataItem<T>>;
+    focusProvider: AbstractFocusProvider<T>;
+    selectionProvider?: AbstractSelectionProvider<T>;
+    disabledKeys: Set<CompositeItemKey>;
+    root: CompositeDataItem<T>;
+    constructor(items: T[], providerOptions: CompositeProviderOptions<T>, options?: CompositeOptions);
+    [Symbol.iterator](): Iterator<CompositeDataItem<T>>;
+    toJSON(): T[];
+    init(items: T[]): void;
+    item(key: CompositeItemKey): CompositeDataItem<T> | undefined;
+    descendants(itemKey: CompositeItemKey): CompositeDataItem<T>[] | undefined;
+    ancestors(itemKey: CompositeItemKey): CompositeDataItem<T>[] | undefined;
+    updateItem(key: CompositeItemKey, data: Partial<T> | ((item: T) => Partial<T>)): void;
+}
+
+declare class CompositeDataItem<T extends object> implements Iterable<CompositeDataItem<T>> {
+    #private;
+    parent: CompositeDataItem<T> | null;
+    children?: CompositeDataItem<T>[];
+    level: number;
+    data: PreinitializedMapStore<T>;
+    state: PreinitializedMapStore<CompositeDataItemState>;
+    pointers: {
+        left?: CompositeItemKey;
+        right?: CompositeItemKey;
+        up?: CompositeItemKey;
+        down?: CompositeItemKey;
+    };
+    childrenProp: string;
+    constructor(item: T, options: CompositeDataItemOptions<T>, parent: CompositeDataItem<T> | null);
+    get key(): CompositeItemKey;
+    [Symbol.iterator](): Iterator<CompositeDataItem<T>>;
+    toJSON(): T;
+    descendants(): CompositeDataItem<T>[];
+    ancestors(): CompositeDataItem<T>[];
+    toggleSelect(recursive?: boolean): void;
+    select(recursive?: boolean): CompositeItemKey[];
+    deselect(recursive?: boolean): CompositeItemKey[];
+    disable(recursive?: boolean): CompositeItemKey[];
+    enable(recursive?: boolean): CompositeItemKey[];
+}
+
+declare type CompositeDataItemOptions<T> = CompositeDataPropGetters<T> & {
+    initialState?: CompositeDataItemState;
+    itemChildrenProp: string;
+};
+
+declare interface CompositeDataItemState {
+    focused: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+
+declare type CompositeDataOptions<T> = Required<CompositeOptions> & CompositeDataPropGetters<T>;
+
+declare interface CompositeDataPropGetters<T> {
+    getItemKey: (item: T) => CompositeItemKey;
+    getItemChildren: (item: T) => T[] | undefined;
+}
+
+declare type CompositeItemKey = string | number;
+
+declare interface CompositeOptions {
+    disabledKeys?: CompositeItemKey[];
+    selectedKeys?: CompositeItemKey[];
+    itemKeyProp?: string;
+    itemChildrenProp?: string;
+}
+
+declare interface CompositeProviderOptions<T extends object> {
+    focusProvider: AbstractFocusProvider<T>;
+    selectionProvider?: AbstractSelectionProvider<T>;
+}
+
+declare interface FocusProvider {
+    focus(itemKey: CompositeItemKey): void;
+    focusUp(): void;
+    focusDown(): void;
+    focusLeft(): void;
+    focusRight(): void;
+    focusPageUp(): void;
+    focesPageDown(): void;
+    focusToFirst(): void;
+    focusToLast(): void;
+    focusToFirstInRow(): void;
+    focusToLastInRow(): void;
+    focusToTypeAheadMatch(): void;
+}
+
+export declare class ListboxFocusProvider<T extends object> extends AbstractFocusProvider<T> {
+    setFocusPointers(): readonly [CompositeDataItem<T> | null, CompositeDataItem<T> | null];
+    focusUp(): void;
+    focusDown(): void;
+    focusLeft(): void;
+    focusRight(): void;
+    focusPageUp(): void;
+    focesPageDown(): void;
+    focusToFirst(): void;
+    focusToLast(): void;
+    focusToFirstInRow(): void;
+    focusToLastInRow(): void;
+    focusToTypeAheadMatch(): void;
+}
+
+export { }

package/dist/ListboxFocusProvider.js

@@ -0,0 +1,53 @@
+import { A as h } from "./AbstractFocusProvider-CxvlcEki.js";
+class l extends h {
+  setFocusPointers() {
+    let i = null, n = null;
+    const t = [...this.data.lookup];
+    for (let e = 0; e < t.length; e++) {
+      const [r, s] = t[e];
+      if (this.isFocusable(s) && (i || (i = s), n = s, e < t.length - 1)) {
+        let o = e === t.length - 1 ? 0 : e + 1;
+        for (; o < t.length && !this.isFocusable(t[o][1]); )
+          o = (o + 1) % t.length;
+        s.pointers.down = t[o][0], t[o][1].pointers.up = r;
+      }
+    }
+    return [i, n];
+  }
+  focusUp() {
+    this.focusedItem.get()?.pointers.up && this.focus(this.focusedItem.get().pointers.up);
+  }
+  focusDown() {
+    this.focusedItem.get()?.pointers.down && this.focus(this.focusedItem.get().pointers.down);
+  }
+  focusLeft() {
+    throw new Error("Method not implemented.");
+  }
+  focusRight() {
+    throw new Error("Method not implemented.");
+  }
+  focusPageUp() {
+    throw new Error("Method not implemented.");
+  }
+  focesPageDown() {
+    throw new Error("Method not implemented.");
+  }
+  focusToFirst() {
+    this.firstFocusableItem && this.focus(this.firstFocusableItem);
+  }
+  focusToLast() {
+    this.lastFocusableItem && this.focus(this.lastFocusableItem);
+  }
+  focusToFirstInRow() {
+    throw new Error("Method not implemented.");
+  }
+  focusToLastInRow() {
+    throw new Error("Method not implemented.");
+  }
+  focusToTypeAheadMatch() {
+    throw new Error("Method not implemented.");
+  }
+}
+export {
+  l as ListboxFocusProvider
+};

package/dist/MultipleSelectionProvider.d.ts

@@ -0,0 +1,141 @@
+import { PreinitializedMapStore } from 'nanostores';
+import { PreinitializedWritableAtom } from 'nanostores';
+
+declare abstract class AbstractFocusProvider<T extends object> implements FocusProvider {
+    protected data: CompositeData<T>;
+    protected dataOptions: CompositeDataOptions<T>;
+    firstFocusableItem: CompositeDataItem<T> | null;
+    lastFocusableItem: CompositeDataItem<T> | null;
+    focusedItem: PreinitializedWritableAtom<CompositeDataItem<T> | null>;
+    init(data: CompositeData<T>, dataOptions: CompositeDataOptions<T>): void;
+    isFocusable(itemAtom: CompositeDataItem<T>): boolean;
+    focus(itemKey: CompositeItemKey): void;
+    focus(item: CompositeDataItem<T>): void;
+    abstract setFocusPointers(): readonly [first: CompositeDataItem<T> | null, last: CompositeDataItem<T> | null];
+    abstract focusUp(): void;
+    abstract focusDown(): void;
+    abstract focusLeft(): void;
+    abstract focusRight(): void;
+    abstract focusPageUp(): void;
+    abstract focesPageDown(): void;
+    abstract focusToFirst(): void;
+    abstract focusToLast(): void;
+    abstract focusToFirstInRow(): void;
+    abstract focusToLastInRow(): void;
+    abstract focusToTypeAheadMatch(): void;
+}
+
+declare abstract class AbstractSelectionProvider<T extends object> {
+    protected data: CompositeData<T>;
+    protected dataOptions: CompositeDataOptions<T>;
+    selectedKeys: PreinitializedWritableAtom<Set<CompositeItemKey>>;
+    init(data: CompositeData<T>, dataOptions: CompositeDataOptions<T>): void;
+    abstract select(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    abstract select(item: CompositeDataItem<T>, recursive?: boolean): void;
+    abstract select(item?: CompositeDataItem<T> | CompositeItemKey, recursive?: boolean): void;
+    abstract deselect(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    abstract deselect(item: CompositeDataItem<T>, recursive?: boolean): void;
+    abstract deselect(item?: CompositeDataItem<T> | CompositeItemKey, recursive?: boolean): void;
+    toggleSelect(itemKey?: CompositeItemKey, recursive?: boolean): void;
+    toggleSelect(item: CompositeDataItem<T>, recursive?: boolean): void;
+}
+
+declare class CompositeData<T extends object> implements Iterable<CompositeDataItem<T>> {
+    #private;
+    lookup: Map<CompositeItemKey, CompositeDataItem<T>>;
+    focusProvider: AbstractFocusProvider<T>;
+    selectionProvider?: AbstractSelectionProvider<T>;
+    disabledKeys: Set<CompositeItemKey>;
+    root: CompositeDataItem<T>;
+    constructor(items: T[], providerOptions: CompositeProviderOptions<T>, options?: CompositeOptions);
+    [Symbol.iterator](): Iterator<CompositeDataItem<T>>;
+    toJSON(): T[];
+    init(items: T[]): void;
+    item(key: CompositeItemKey): CompositeDataItem<T> | undefined;
+    descendants(itemKey: CompositeItemKey): CompositeDataItem<T>[] | undefined;
+    ancestors(itemKey: CompositeItemKey): CompositeDataItem<T>[] | undefined;
+    updateItem(key: CompositeItemKey, data: Partial<T> | ((item: T) => Partial<T>)): void;
+}
+
+declare class CompositeDataItem<T extends object> implements Iterable<CompositeDataItem<T>> {
+    #private;
+    parent: CompositeDataItem<T> | null;
+    children?: CompositeDataItem<T>[];
+    level: number;
+    data: PreinitializedMapStore<T>;
+    state: PreinitializedMapStore<CompositeDataItemState>;
+    pointers: {
+        left?: CompositeItemKey;
+        right?: CompositeItemKey;
+        up?: CompositeItemKey;
+        down?: CompositeItemKey;
+    };
+    childrenProp: string;
+    constructor(item: T, options: CompositeDataItemOptions<T>, parent: CompositeDataItem<T> | null);
+    get key(): CompositeItemKey;
+    [Symbol.iterator](): Iterator<CompositeDataItem<T>>;
+    toJSON(): T;
+    descendants(): CompositeDataItem<T>[];
+    ancestors(): CompositeDataItem<T>[];
+    toggleSelect(recursive?: boolean): void;
+    select(recursive?: boolean): CompositeItemKey[];
+    deselect(recursive?: boolean): CompositeItemKey[];
+    disable(recursive?: boolean): CompositeItemKey[];
+    enable(recursive?: boolean): CompositeItemKey[];
+}
+
+declare type CompositeDataItemOptions<T> = CompositeDataPropGetters<T> & {
+    initialState?: CompositeDataItemState;
+    itemChildrenProp: string;
+};
+
+declare interface CompositeDataItemState {
+    focused: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+
+declare type CompositeDataOptions<T> = Required<CompositeOptions> & CompositeDataPropGetters<T>;
+
+declare interface CompositeDataPropGetters<T> {
+    getItemKey: (item: T) => CompositeItemKey;
+    getItemChildren: (item: T) => T[] | undefined;
+}
+
+declare type CompositeItemKey = string | number;
+
+declare interface CompositeOptions {
+    disabledKeys?: CompositeItemKey[];
+    selectedKeys?: CompositeItemKey[];
+    itemKeyProp?: string;
+    itemChildrenProp?: string;
+}
+
+declare interface CompositeProviderOptions<T extends object> {
+    focusProvider: AbstractFocusProvider<T>;
+    selectionProvider?: AbstractSelectionProvider<T>;
+}
+
+declare interface FocusProvider {
+    focus(itemKey: CompositeItemKey): void;
+    focusUp(): void;
+    focusDown(): void;
+    focusLeft(): void;
+    focusRight(): void;
+    focusPageUp(): void;
+    focesPageDown(): void;
+    focusToFirst(): void;
+    focusToLast(): void;
+    focusToFirstInRow(): void;
+    focusToLastInRow(): void;
+    focusToTypeAheadMatch(): void;
+}
+
+export declare class SingleSelectionProvider<T extends object> extends AbstractSelectionProvider<T> {
+    select(itemKey: CompositeItemKey, recursive?: boolean): void;
+    select(item: CompositeDataItem<T>, recursive?: boolean): void;
+    deselect(itemKey: CompositeItemKey, recursive?: boolean): void;
+    deselect(item: CompositeDataItem<T>, recursive?: boolean): void;
+}
+
+export { }

package/dist/MultipleSelectionProvider.js

@@ -0,0 +1,19 @@
+import { C as c } from "./CompositeDataItem-DuHOHCWy.js";
+import { A as i, u as l, d as n } from "./AbstractSelectionProvider-BtaROstC.js";
+class f extends i {
+  select(e, t = !1) {
+    const s = e instanceof c ? e : this.data.lookup.get(e);
+    if (!s) return;
+    const o = s.select(t);
+    this.selectedKeys.set(l(this.selectedKeys.get(), o));
+  }
+  deselect(e, t = !1) {
+    const s = e instanceof c ? e : this.data.lookup.get(e);
+    if (!s) return;
+    const o = s.deselect(t);
+    this.selectedKeys.set(n(this.selectedKeys.get(), o));
+  }
+}
+export {
+  f as SingleSelectionProvider
+};