@iris-ui-kit/vue 0.1.0

package/dist/admin.d.ts

@@ -0,0 +1,376 @@
+import * as vue from 'vue';
+import { PropType, VNode, ComputedRef, MaybeRefOrGetter } from 'vue';
+import { NavNode, TabsNav, TabItem } from '@iris-ui-kit/core';
+export { NavNode, TabItem, TabsNav, TabsNavConfig, TabsNavState, createTabsNav, findNavNode, findNavPath, firstLeaf, flattenNav, isBranch, isClosable, visibleNav } from '@iris-ui-kit/core';
+
+type IrisAdminLayoutMode = 'sidebar' | 'full-content';
+/**
+ * The CMS / admin shell — a Vben-style, router-agnostic, data-driven layout that
+ * composes IrisSidebarLayout + IrisHeaderLayout with the admin nav pieces. One
+ * `menus` tree drives the collapsible sidebar nav, the header breadcrumb, and
+ * (when a `tabs` store is passed) the multi-tab bar; `activeKey` is the current
+ * page (v-model). The host owns routing: react to `@select` / `update:activeKey`
+ * and render the page in the default slot (wrap it in `<KeepAlive>` keyed by
+ * `tabs.cacheKey` for Vben-style tab caching).
+ *
+ * Slots: `logo({ collapsed })`, `toolbar` (header end), default `({ activeKey })`,
+ * `footer`. Modes: `sidebar` (default) and `full-content` (chrome hidden).
+ */
+declare const IrisAdminLayout: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Normalized nav tree driving menu + breadcrumb. */
+    menus: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Active page key (v-model:activeKey). */
+    activeKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Sidebar collapsed (v-model:collapsed); undefined = uncontrolled. */
+    collapsed: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mode: {
+        type: PropType<IrisAdminLayoutMode>;
+        default: string;
+    };
+    /** Brand text shown next to the logo when expanded. */
+    appTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Optional shared tabs store; when present the tab bar is rendered. */
+    tabs: {
+        type: PropType<TabsNav>;
+        default: undefined;
+    };
+    showBreadcrumb: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sidebarWidth: {
+        type: PropType<number | string>;
+        default: number;
+    };
+    collapsedWidth: {
+        type: PropType<number | string>;
+        default: number;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:activeKey': (_key: string) => true;
+    'update:collapsed': (_value: boolean) => true;
+    select: (_key: string, _node: NavNode) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Normalized nav tree driving menu + breadcrumb. */
+    menus: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Active page key (v-model:activeKey). */
+    activeKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Sidebar collapsed (v-model:collapsed); undefined = uncontrolled. */
+    collapsed: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mode: {
+        type: PropType<IrisAdminLayoutMode>;
+        default: string;
+    };
+    /** Brand text shown next to the logo when expanded. */
+    appTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Optional shared tabs store; when present the tab bar is rendered. */
+    tabs: {
+        type: PropType<TabsNav>;
+        default: undefined;
+    };
+    showBreadcrumb: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sidebarWidth: {
+        type: PropType<number | string>;
+        default: number;
+    };
+    collapsedWidth: {
+        type: PropType<number | string>;
+        default: number;
+    };
+}>> & Readonly<{
+    onSelect?: ((_key: string, _node: NavNode) => any) | undefined;
+    "onUpdate:collapsed"?: ((_value: boolean) => any) | undefined;
+    "onUpdate:activeKey"?: ((_key: string) => any) | undefined;
+}>, {
+    mode: IrisAdminLayoutMode;
+    collapsed: boolean | undefined;
+    defaultCollapsed: boolean;
+    collapsedWidth: string | number;
+    activeKey: string;
+    tabs: TabsNav;
+    appTitle: string;
+    showBreadcrumb: boolean;
+    sidebarWidth: string | number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Data-driven nested navigation menu — the sidebar nav of the admin shell.
+ * Renders a normalized `NavNode[]` tree as an accordion of expandable branches
+ * and selectable leaves; the active leaf and its ancestor branches are
+ * highlighted, and the active branch trail auto-expands. Router-agnostic: it
+ * takes `activeKey` + emits `select(key, node)`; the host owns navigation.
+ *
+ * `collapsed` switches to an icon-only rail (top-level items only); a branch
+ * click then jumps to its first leaf.
+ */
+declare const IrisNavMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Normalized nav tree. */
+    items: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Key of the active leaf. */
+    activeKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Controlled expanded branch keys (v-model:expandedKeys). */
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** Initial expanded keys when uncontrolled (else the active trail expands). */
+    defaultExpandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** Icon-only rail (top-level items only). */
+    collapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    select: (_key: string, _node: NavNode) => true;
+    'update:expandedKeys': (_keys: string[]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Normalized nav tree. */
+    items: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Key of the active leaf. */
+    activeKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Controlled expanded branch keys (v-model:expandedKeys). */
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** Initial expanded keys when uncontrolled (else the active trail expands). */
+    defaultExpandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** Icon-only rail (top-level items only). */
+    collapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onSelect?: ((_key: string, _node: NavNode) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((_keys: string[]) => any) | undefined;
+}>, {
+    collapsed: boolean;
+    activeKey: string;
+    expandedKeys: string[];
+    defaultExpandedKeys: string[];
+    ariaLabel: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Breadcrumb trail for the admin header, driven by a `NavNode[]` ancestor chain
+ * (typically `findNavPath(menus, activeKey)`). The last crumb is the current
+ * page (auto-marked `aria-current` by IrisBreadcrumb); earlier crumbs are
+ * clickable and emit `select(key, node)` so the host can navigate.
+ */
+declare const IrisAdminBreadcrumb: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Root→current ancestor chain. */
+    trail: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Show each node's icon before its title. */
+    showIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Hide the breadcrumb when the trail has a single crumb. */
+    hideSingle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    select: (_key: string, _node: NavNode) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Root→current ancestor chain. */
+    trail: {
+        type: PropType<NavNode[]>;
+        required: true;
+    };
+    /** Show each node's icon before its title. */
+    showIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Hide the breadcrumb when the trail has a single crumb. */
+    hideSingle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onSelect?: ((_key: string, _node: NavNode) => any) | undefined;
+}>, {
+    separator: string;
+    showIcon: boolean;
+    hideSingle: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Vben-style multi-tab bar over a shared {@link TabsNav} store. Each open page
+ * is a closable chip; clicking activates (`@change`), the × closes, and a
+ * trailing actions dropdown runs Refresh / Close / Close-others / Close-all on
+ * the active tab. The store owns the tab list + active key; the host watches it
+ * to sync routing + keep-alive.
+ *
+ * Keyboard (WAI-ARIA tablist, automatic activation): ←/→ move + activate the
+ * adjacent tab, Home/End jump to the first/last, Delete/Backspace closes the
+ * focused tab. Roving tabindex keeps a single tab stop.
+ */
+declare const IrisAdminTabs: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Shared tabs store (from `createTabsNav`). */
+    nav: {
+        type: PropType<TabsNav>;
+        required: true;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_key: string) => true;
+    close: (_key: string) => true;
+    refresh: (_key: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Shared tabs store (from `createTabsNav`). */
+    nav: {
+        type: PropType<TabsNav>;
+        required: true;
+    };
+}>> & Readonly<{
+    onChange?: ((_key: string) => any) | undefined;
+    onClose?: ((_key: string) => any) | undefined;
+    onRefresh?: ((_key: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface UseTabsNavReturn {
+    tabs: ComputedRef<TabItem[]>;
+    activeKey: ComputedRef<string | undefined>;
+    /** Keep-alive include-set (composite cache keys of all open tabs). */
+    cacheKeys: ComputedRef<string[]>;
+    open: TabsNav['open'];
+    activate: TabsNav['activate'];
+    close: TabsNav['close'];
+    closeOthers: TabsNav['closeOthers'];
+    closeAll: TabsNav['closeAll'];
+    closeLeft: TabsNav['closeLeft'];
+    closeRight: TabsNav['closeRight'];
+    refresh: TabsNav['refresh'];
+    setPinned: TabsNav['setPinned'];
+    cacheKey: TabsNav['cacheKey'];
+}
+/**
+ * Vue binding for a framework-agnostic {@link TabsNav} store. Pass a shared
+ * `createTabsNav()` instance (the host owns it so the tab bar and the keep-alive
+ * content can read the same state) and get reactive `tabs` / `activeKey` /
+ * `cacheKeys` plus the store's mutators.
+ *
+ * ```ts
+ * const nav = createTabsNav({ tabs: [{ key: 'home', title: 'Home', pinned: true }] })
+ * const { tabs, activeKey, open, close } = useTabsNav(nav)
+ * ```
+ */
+declare function useTabsNav(nav: TabsNav): UseTabsNavReturn;
+
+interface UseAdminShellConfig {
+    /** Normalized nav tree driving menu + breadcrumb. */
+    menus: MaybeRefOrGetter<NavNode[]>;
+    /** Active page key (controlled); undefined = uncontrolled. */
+    activeKey?: MaybeRefOrGetter<string | undefined>;
+    defaultActiveKey?: string;
+    onActiveKeyChange?: (key: string) => void;
+    /** Fired whenever a nav node / tab becomes active, with the resolved leaf node. */
+    onSelect?: (key: string, node: NavNode) => void;
+    /** Optional shared tabs store; the shell opens/reconciles tabs through it. */
+    tabs?: TabsNav;
+}
+interface UseAdminShellReturn {
+    /** Current active leaf key ('' when none). */
+    activeKey: ComputedRef<string>;
+    /** Select a nav node: a branch redirects to its first leaf, opens its tab. */
+    navigate: (node: NavNode) => void;
+    /** Reconcile when the active TAB changed (e.g. a close picked a neighbor). */
+    syncFromTab: (key: string) => void;
+    /** Ancestor→node breadcrumb trail of the active key. */
+    breadcrumb: ComputedRef<NavNode[]>;
+}
+/**
+ * Vue binding for the framework-agnostic {@link createAdminShell} controller —
+ * the menu→tab→active-key wiring that every AdminLayout used to re-implement
+ * byte-for-byte. The composable owns the controlled/uncontrolled `activeKey`
+ * reconciliation (idiomatic to Vue) and delegates navigate / syncFromTab /
+ * branch-resolution / breadcrumb to the shared core shell.
+ *
+ * Controlled mode renders from the prop directly (no flicker); a watcher keeps
+ * the shell's guard-base synced to the prop so the active-change callback fires
+ * with the same semantics as before.
+ */
+declare function useAdminShell(config: UseAdminShellConfig): UseAdminShellReturn;
+
+export { IrisAdminBreadcrumb, IrisAdminLayout, type IrisAdminLayoutMode, IrisAdminTabs, IrisNavMenu, type UseAdminShellConfig, type UseAdminShellReturn, type UseTabsNavReturn, useAdminShell, useTabsNav };

package/dist/admin.js

@@ -0,0 +1,10 @@
+export { IrisAdminBreadcrumb, IrisAdminLayout, IrisAdminTabs, IrisNavMenu, createTabsNav, findNavNode, findNavPath, firstLeaf, flattenNav, isBranch, isClosable, useAdminShell, useTabsNav, visibleNav } from './chunk-FJBYAIL4.js';
+import './chunk-3FJUCHCC.js';
+import './chunk-TQB5LVOH.js';
+import './chunk-F77KIPOH.js';
+import './chunk-I6D5VXQK.js';
+import './chunk-72PZMU6R.js';
+import './chunk-75GSYEJS.js';
+import './chunk-TCAXRWT6.js';
+//# sourceMappingURL=admin.js.map
+//# sourceMappingURL=admin.js.map

package/dist/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"admin.js"}

package/dist/async.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var vue = require('vue');
+var core = require('@iris-ui-kit/core');
+
+// src/async/useAsyncResource.ts
+function useAsyncResource(fetcher, options = {}) {
+  const config = "initialData" in options ? { initialData: options.initialData } : {};
+  const resource = core.createAsyncResource(fetcher, config);
+  const state = vue.ref(resource.getState());
+  const unsubscribe = resource.subscribe((next) => {
+    state.value = next;
+  });
+  vue.onBeforeUnmount(() => {
+    unsubscribe();
+    resource.cancel();
+  });
+  if (options.immediate) {
+    vue.onMounted(() => {
+      void resource.load(...[]);
+    });
+  }
+  return {
+    status: vue.computed(() => state.value.status),
+    data: vue.computed(() => state.value.data),
+    error: vue.computed(() => state.value.error),
+    isLoading: vue.computed(() => state.value.status === "loading"),
+    isError: vue.computed(() => state.value.status === "error"),
+    load: resource.load,
+    reload: resource.reload,
+    mutate: resource.mutate,
+    cancel: resource.cancel,
+    reset: resource.reset
+  };
+}
+function usePaginatedResource(fetcher, options = {}) {
+  const resource = core.createPaginatedResource(fetcher, {
+    pageSize: options.pageSize,
+    mode: options.mode
+  });
+  const state = vue.ref(resource.getState());
+  const unsubscribe = resource.subscribe((next) => {
+    state.value = next;
+  });
+  vue.onBeforeUnmount(unsubscribe);
+  if (options.immediate) {
+    vue.onMounted(() => {
+      void (options.mode === "infinite" ? resource.loadMore() : resource.goToPage(1));
+    });
+  }
+  return {
+    status: vue.computed(() => state.value.status),
+    items: vue.computed(() => state.value.items),
+    page: vue.computed(() => state.value.page),
+    pageSize: vue.computed(() => state.value.pageSize),
+    total: vue.computed(() => state.value.total),
+    error: vue.computed(() => state.value.error),
+    isLoading: vue.computed(() => state.value.status === "loading"),
+    isError: vue.computed(() => state.value.status === "error"),
+    // Touch state so this recomputes on every store change; hasMore() then
+    // reads the resource's fresh internal batch state.
+    hasMore: vue.computed(() => {
+      void state.value;
+      return resource.hasMore();
+    }),
+    goToPage: resource.goToPage,
+    loadMore: resource.loadMore,
+    refresh: resource.refresh,
+    setPageSize: resource.setPageSize
+  };
+}
+
+exports.useAsyncResource = useAsyncResource;
+exports.usePaginatedResource = usePaginatedResource;
+//# sourceMappingURL=async.cjs.map
+//# sourceMappingURL=async.cjs.map

package/dist/async.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/async/useAsyncResource.ts","../src/async/usePaginatedResource.ts"],"names":["createAsyncResource","ref","onBeforeUnmount","onMounted","computed","createPaginatedResource"],"mappings":";;;;;;AAqCO,SAAS,gBAAA,CACd,OAAA,EACA,OAAA,GAAsC,EAAC,EACT;AAC9B,EAAA,MAAM,MAAA,GACJ,iBAAiB,OAAA,GAAU,EAAE,aAAa,OAAA,CAAQ,WAAA,KAAgB,EAAC;AACrE,EAAA,MAAM,QAAA,GAAWA,wBAAA,CAA0B,OAAA,EAAS,MAAM,CAAA;AAE1D,EAAA,MAAM,KAAA,GAAQC,OAAA,CAAI,QAAA,CAAS,QAAA,EAAU,CAAA;AACrC,EAAA,MAAM,WAAA,GAAc,QAAA,CAAS,SAAA,CAAU,CAAC,IAAA,KAAS;AAC/C,IAAA,KAAA,CAAM,KAAA,GAAQ,IAAA;AAAA,EAChB,CAAC,CAAA;AACD,EAAAC,mBAAA,CAAgB,MAAM;AACpB,IAAA,WAAA,EAAY;AAIZ,IAAA,QAAA,CAAS,MAAA,EAAO;AAAA,EAClB,CAAC,CAAA;AAED,EAAA,IAAI,QAAQ,SAAA,EAAW;AACrB,IAAAC,aAAA,CAAU,MAAM;AACd,MAAA,KAAK,QAAA,CAAS,IAAA,CAAK,GAAI,EAAmB,CAAA;AAAA,IAC5C,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,OAAO;AAAA,IACL,MAAA,EAAQC,YAAA,CAAS,MAAM,KAAA,CAAM,MAAM,MAAM,CAAA;AAAA,IACzC,IAAA,EAAMA,YAAA,CAAS,MAAM,KAAA,CAAM,MAAM,IAAI,CAAA;AAAA,IACrC,KAAA,EAAOA,YAAA,CAAS,MAAM,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IACvC,WAAWA,YAAA,CAAS,MAAM,KAAA,CAAM,KAAA,CAAM,WAAW,SAAS,CAAA;AAAA,IAC1D,SAASA,YAAA,CAAS,MAAM,KAAA,CAAM,KAAA,CAAM,WAAW,OAAO,CAAA;AAAA,IACtD,MAAM,QAAA,CAAS,IAAA;AAAA,IACf,QAAQ,QAAA,CAAS,MAAA;AAAA,IACjB,QAAQ,QAAA,CAAS,MAAA;AAAA,IACjB,QAAQ,QAAA,CAAS,MAAA;AAAA,IACjB,OAAO,QAAA,CAAS;AAAA,GAClB;AACF;ACtCO,SAAS,oBAAA,CACd,OAAA,EACA,OAAA,GAAuC,EAAC,EACT;AAC/B,EAAA,MAAM,QAAA,GAAWC,6BAA2B,OAAA,EAAS;AAAA,IACnD,UAAU,OAAA,CAAQ,QAAA;AAAA,IAClB,MAAM,OAAA,CAAQ;AAAA,GACf,CAAA;AAED,EAAA,MAAM,KAAA,GAAQJ,OAAAA,CAAI,QAAA,CAAS,QAAA,EAAU,CAAA;AACrC,EAAA,MAAM,WAAA,GAAc,QAAA,CAAS,SAAA,CAAU,CAAC,IAAA,KAAS;AAC/C,IAAA,KAAA,CAAM,KAAA,GAAQ,IAAA;AAAA,EAChB,CAAC,CAAA;AACD,EAAAC,oBAAgB,WAAW,CAAA;AAE3B,EAAA,IAAI,QAAQ,SAAA,EAAW;AACrB,IAAAC,cAAU,MAAM;AACd,MAAA,MAAM,OAAA,CAAQ,SAAS,UAAA,GAAa,QAAA,CAAS,UAAS,GAAI,QAAA,CAAS,SAAS,CAAC,CAAA,CAAA;AAAA,IAC/E,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,OAAO;AAAA,IACL,MAAA,EAAQC,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,MAAM,CAAA;AAAA,IACzC,KAAA,EAAOA,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IACvC,IAAA,EAAMA,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,IAAI,CAAA;AAAA,IACrC,QAAA,EAAUA,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,QAAQ,CAAA;AAAA,IAC7C,KAAA,EAAOA,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IACvC,KAAA,EAAOA,YAAAA,CAAS,MAAM,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IACvC,WAAWA,YAAAA,CAAS,MAAM,KAAA,CAAM,KAAA,CAAM,WAAW,SAAS,CAAA;AAAA,IAC1D,SAASA,YAAAA,CAAS,MAAM,KAAA,CAAM,KAAA,CAAM,WAAW,OAAO,CAAA;AAAA;AAAA;AAAA,IAGtD,OAAA,EAASA,aAAS,MAAM;AACtB,MAAA,KAAK,KAAA,CAAM,KAAA;AACX,MAAA,OAAO,SAAS,OAAA,EAAQ;AAAA,IAC1B,CAAC,CAAA;AAAA,IACD,UAAU,QAAA,CAAS,QAAA;AAAA,IACnB,UAAU,QAAA,CAAS,QAAA;AAAA,IACnB,SAAS,QAAA,CAAS,OAAA;AAAA,IAClB,aAAa,QAAA,CAAS;AAAA,GACxB;AACF","file":"async.cjs","sourcesContent":["import { computed, onBeforeUnmount, onMounted, ref, type ComputedRef, type Ref } from 'vue'\nimport {\n  createAsyncResource,\n  type AsyncResource,\n  type AsyncResourceConfig,\n  type AsyncState,\n  type AsyncStatus,\n} from '@iris-ui-kit/core'\n\nexport interface UseAsyncResourceOptions<T> extends AsyncResourceConfig<T> {\n  /** Run `load()` (no params) once on mount. Default `false`. */\n  immediate?: boolean\n}\n\nexport interface UseAsyncResourceReturn<T, P extends unknown[]> {\n  status: ComputedRef<AsyncStatus>\n  data: ComputedRef<T | undefined>\n  error: ComputedRef<unknown>\n  isLoading: ComputedRef<boolean>\n  isError: ComputedRef<boolean>\n  load: AsyncResource<T, P>['load']\n  reload: AsyncResource<T, P>['reload']\n  mutate: AsyncResource<T, P>['mutate']\n  cancel: AsyncResource<T, P>['cancel']\n  reset: AsyncResource<T, P>['reset']\n}\n\n/**\n * Vue binding for the framework-agnostic async resource. Creates the resource\n * in `setup()` (runs once, so the fetcher closure stays live) and bridges its\n * state into computed refs.\n *\n * ```ts\n * const users = useAsyncResource(() => api.listUsers(), { immediate: true })\n * // <IrisTable :data=\"users.data.value ?? []\" :loading=\"users.isLoading.value\" />\n * ```\n */\nexport function useAsyncResource<T, P extends unknown[] = []>(\n  fetcher: (...params: P) => Promise<T>,\n  options: UseAsyncResourceOptions<T> = {},\n): UseAsyncResourceReturn<T, P> {\n  const config: AsyncResourceConfig<T> =\n    'initialData' in options ? { initialData: options.initialData } : {}\n  const resource = createAsyncResource<T, P>(fetcher, config)\n\n  const state = ref(resource.getState()) as Ref<AsyncState<T>>\n  const unsubscribe = resource.subscribe((next) => {\n    state.value = next\n  })\n  onBeforeUnmount(() => {\n    unsubscribe()\n    // Abort any in-flight request on unmount so it can't write back into an\n    // unmounted component (and cancels the underlying request when the fetcher\n    // honors `signal`). Idempotent and safe with no in-flight load.\n    resource.cancel()\n  })\n\n  if (options.immediate) {\n    onMounted(() => {\n      void resource.load(...([] as unknown as P))\n    })\n  }\n\n  return {\n    status: computed(() => state.value.status),\n    data: computed(() => state.value.data),\n    error: computed(() => state.value.error),\n    isLoading: computed(() => state.value.status === 'loading'),\n    isError: computed(() => state.value.status === 'error'),\n    load: resource.load,\n    reload: resource.reload,\n    mutate: resource.mutate,\n    cancel: resource.cancel,\n    reset: resource.reset,\n  }\n}\n","import { computed, onBeforeUnmount, onMounted, ref, type ComputedRef, type Ref } from 'vue'\nimport {\n  createPaginatedResource,\n  type PageQuery,\n  type PageResult,\n  type PaginatedResource,\n  type PaginatedState,\n  type PaginationMode,\n} from '@iris-ui-kit/core'\n\nexport interface UsePaginatedResourceOptions {\n  pageSize?: number\n  mode?: PaginationMode\n  /** Load the first page on mount (page 1, or `loadMore` in infinite mode). */\n  immediate?: boolean\n}\n\nexport interface UsePaginatedResourceReturn<T> {\n  status: ComputedRef<PaginatedState<T>['status']>\n  items: ComputedRef<T[]>\n  page: ComputedRef<number>\n  pageSize: ComputedRef<number>\n  total: ComputedRef<number | undefined>\n  error: ComputedRef<unknown>\n  isLoading: ComputedRef<boolean>\n  isError: ComputedRef<boolean>\n  hasMore: ComputedRef<boolean>\n  goToPage: PaginatedResource<T>['goToPage']\n  loadMore: PaginatedResource<T>['loadMore']\n  refresh: PaginatedResource<T>['refresh']\n  setPageSize: PaginatedResource<T>['setPageSize']\n}\n\n/**\n * Vue binding for the server-side pagination resource. Created in `setup()`\n * (fetcher closure stays live) and bridged to computed refs.\n */\nexport function usePaginatedResource<T>(\n  fetcher: (query: PageQuery) => Promise<PageResult<T>>,\n  options: UsePaginatedResourceOptions = {},\n): UsePaginatedResourceReturn<T> {\n  const resource = createPaginatedResource<T>(fetcher, {\n    pageSize: options.pageSize,\n    mode: options.mode,\n  })\n\n  const state = ref(resource.getState()) as Ref<PaginatedState<T>>\n  const unsubscribe = resource.subscribe((next) => {\n    state.value = next\n  })\n  onBeforeUnmount(unsubscribe)\n\n  if (options.immediate) {\n    onMounted(() => {\n      void (options.mode === 'infinite' ? resource.loadMore() : resource.goToPage(1))\n    })\n  }\n\n  return {\n    status: computed(() => state.value.status),\n    items: computed(() => state.value.items),\n    page: computed(() => state.value.page),\n    pageSize: computed(() => state.value.pageSize),\n    total: computed(() => state.value.total),\n    error: computed(() => state.value.error),\n    isLoading: computed(() => state.value.status === 'loading'),\n    isError: computed(() => state.value.status === 'error'),\n    // Touch state so this recomputes on every store change; hasMore() then\n    // reads the resource's fresh internal batch state.\n    hasMore: computed(() => {\n      void state.value\n      return resource.hasMore()\n    }),\n    goToPage: resource.goToPage,\n    loadMore: resource.loadMore,\n    refresh: resource.refresh,\n    setPageSize: resource.setPageSize,\n  }\n}\n"]}

package/dist/async.d.cts

@@ -0,0 +1,59 @@
+import { ComputedRef } from 'vue';
+import { AsyncResourceConfig, AsyncStatus, AsyncResource, PaginationMode, PaginatedState, PaginatedResource, PageQuery, PageResult } from '@iris-ui-kit/core';
+
+interface UseAsyncResourceOptions<T> extends AsyncResourceConfig<T> {
+    /** Run `load()` (no params) once on mount. Default `false`. */
+    immediate?: boolean;
+}
+interface UseAsyncResourceReturn<T, P extends unknown[]> {
+    status: ComputedRef<AsyncStatus>;
+    data: ComputedRef<T | undefined>;
+    error: ComputedRef<unknown>;
+    isLoading: ComputedRef<boolean>;
+    isError: ComputedRef<boolean>;
+    load: AsyncResource<T, P>['load'];
+    reload: AsyncResource<T, P>['reload'];
+    mutate: AsyncResource<T, P>['mutate'];
+    cancel: AsyncResource<T, P>['cancel'];
+    reset: AsyncResource<T, P>['reset'];
+}
+/**
+ * Vue binding for the framework-agnostic async resource. Creates the resource
+ * in `setup()` (runs once, so the fetcher closure stays live) and bridges its
+ * state into computed refs.
+ *
+ * ```ts
+ * const users = useAsyncResource(() => api.listUsers(), { immediate: true })
+ * // <IrisTable :data="users.data.value ?? []" :loading="users.isLoading.value" />
+ * ```
+ */
+declare function useAsyncResource<T, P extends unknown[] = []>(fetcher: (...params: P) => Promise<T>, options?: UseAsyncResourceOptions<T>): UseAsyncResourceReturn<T, P>;
+
+interface UsePaginatedResourceOptions {
+    pageSize?: number;
+    mode?: PaginationMode;
+    /** Load the first page on mount (page 1, or `loadMore` in infinite mode). */
+    immediate?: boolean;
+}
+interface UsePaginatedResourceReturn<T> {
+    status: ComputedRef<PaginatedState<T>['status']>;
+    items: ComputedRef<T[]>;
+    page: ComputedRef<number>;
+    pageSize: ComputedRef<number>;
+    total: ComputedRef<number | undefined>;
+    error: ComputedRef<unknown>;
+    isLoading: ComputedRef<boolean>;
+    isError: ComputedRef<boolean>;
+    hasMore: ComputedRef<boolean>;
+    goToPage: PaginatedResource<T>['goToPage'];
+    loadMore: PaginatedResource<T>['loadMore'];
+    refresh: PaginatedResource<T>['refresh'];
+    setPageSize: PaginatedResource<T>['setPageSize'];
+}
+/**
+ * Vue binding for the server-side pagination resource. Created in `setup()`
+ * (fetcher closure stays live) and bridged to computed refs.
+ */
+declare function usePaginatedResource<T>(fetcher: (query: PageQuery) => Promise<PageResult<T>>, options?: UsePaginatedResourceOptions): UsePaginatedResourceReturn<T>;
+
+export { type UseAsyncResourceOptions, type UseAsyncResourceReturn, type UsePaginatedResourceOptions, type UsePaginatedResourceReturn, useAsyncResource, usePaginatedResource };

package/dist/async.d.ts

@@ -0,0 +1,59 @@
+import { ComputedRef } from 'vue';
+import { AsyncResourceConfig, AsyncStatus, AsyncResource, PaginationMode, PaginatedState, PaginatedResource, PageQuery, PageResult } from '@iris-ui-kit/core';
+
+interface UseAsyncResourceOptions<T> extends AsyncResourceConfig<T> {
+    /** Run `load()` (no params) once on mount. Default `false`. */
+    immediate?: boolean;
+}
+interface UseAsyncResourceReturn<T, P extends unknown[]> {
+    status: ComputedRef<AsyncStatus>;
+    data: ComputedRef<T | undefined>;
+    error: ComputedRef<unknown>;
+    isLoading: ComputedRef<boolean>;
+    isError: ComputedRef<boolean>;
+    load: AsyncResource<T, P>['load'];
+    reload: AsyncResource<T, P>['reload'];
+    mutate: AsyncResource<T, P>['mutate'];
+    cancel: AsyncResource<T, P>['cancel'];
+    reset: AsyncResource<T, P>['reset'];
+}
+/**
+ * Vue binding for the framework-agnostic async resource. Creates the resource
+ * in `setup()` (runs once, so the fetcher closure stays live) and bridges its
+ * state into computed refs.
+ *
+ * ```ts
+ * const users = useAsyncResource(() => api.listUsers(), { immediate: true })
+ * // <IrisTable :data="users.data.value ?? []" :loading="users.isLoading.value" />
+ * ```
+ */
+declare function useAsyncResource<T, P extends unknown[] = []>(fetcher: (...params: P) => Promise<T>, options?: UseAsyncResourceOptions<T>): UseAsyncResourceReturn<T, P>;
+
+interface UsePaginatedResourceOptions {
+    pageSize?: number;
+    mode?: PaginationMode;
+    /** Load the first page on mount (page 1, or `loadMore` in infinite mode). */
+    immediate?: boolean;
+}
+interface UsePaginatedResourceReturn<T> {
+    status: ComputedRef<PaginatedState<T>['status']>;
+    items: ComputedRef<T[]>;
+    page: ComputedRef<number>;
+    pageSize: ComputedRef<number>;
+    total: ComputedRef<number | undefined>;
+    error: ComputedRef<unknown>;
+    isLoading: ComputedRef<boolean>;
+    isError: ComputedRef<boolean>;
+    hasMore: ComputedRef<boolean>;
+    goToPage: PaginatedResource<T>['goToPage'];
+    loadMore: PaginatedResource<T>['loadMore'];
+    refresh: PaginatedResource<T>['refresh'];
+    setPageSize: PaginatedResource<T>['setPageSize'];
+}
+/**
+ * Vue binding for the server-side pagination resource. Created in `setup()`
+ * (fetcher closure stays live) and bridged to computed refs.
+ */
+declare function usePaginatedResource<T>(fetcher: (query: PageQuery) => Promise<PageResult<T>>, options?: UsePaginatedResourceOptions): UsePaginatedResourceReturn<T>;
+
+export { type UseAsyncResourceOptions, type UseAsyncResourceReturn, type UsePaginatedResourceOptions, type UsePaginatedResourceReturn, useAsyncResource, usePaginatedResource };

package/dist/async.js

@@ -0,0 +1,3 @@
+export { useAsyncResource, usePaginatedResource } from './chunk-ZY4NLITM.js';
+//# sourceMappingURL=async.js.map
+//# sourceMappingURL=async.js.map

package/dist/async.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"async.js"}