@ulu/frontend-vue 0.1.0-beta.3 → 0.1.0-beta.31

package/lib/utils/{vue-router.js → router.js}

@@ -1,9 +1,29 @@
 /**
  * This Module Creates Menus from route or router config
  * - Note: Functions prefixed with "$" work with $route objects (running application, provided by vue-router ie $router, useRoute, etc), 
- * @module utils/router-utils
+ * @module router-utils
  */
 
+/**
+ * Resolves a route's title from its meta.
+ * - If `meta.title` is a function, it's called with the `currentRoute` (or the route itself).
+ * - Otherwise, `meta.title` is returned.
+ * This function is the single source of truth for resolving titles from route configuration.
+ * @param {object} route The route or route match object.
+ * @param {object} [currentRoute] The current route from `useRoute()`, passed to functional titles.
+ * @returns {string|undefined} The resolved title, or undefined if not found.
+ */
+export function getRouteTitle(route, currentRoute) {
+  const meta = route?.meta || {};
+  let title = meta.title;
+
+  if (typeof title === "function") {
+    title = title(currentRoute || route);
+  }
+
+  return title;
+}
+
 /**
  * Route Menu Item
  * @typedef {Object} RouteMenuItem
@@ -21,21 +41,55 @@
  */
 export function createBaseMenu(routes, options) {
   const defaults = {
-    qualifier: isStaticBaseRoute,
+    qualifier(route, parentPath) {
+      if (!parentPath) {
+        return isStaticBaseRoute(route);
+      } else {
+        return isStaticRoute(route);
+      }
+    },
     sort: sortByWeight,
-    item: {}
+    item: {},
+    includeChildren: false
   };
   const opts = Object.assign({}, defaults, options);
-  return routes
-    .filter(opts.qualifier)
-    .map(r => {
-      // Need to grab meta from child but use the parent path
-      const menuRoute = r.children ? getChildIndexRoute(r.children) : r;
-      return createMenuItem(menuRoute, r.path, opts.item);
-    })
-    .sort(opts.sort);
+  const getItemPath = (r, parentPath) => parentPath ? `${ parentPath }/${ r.path }` : r.path;
+  const toMenuItems = (currentRoutes, parentPath = null) => {
+    return currentRoutes
+      .filter(r => opts.qualifier(r, parentPath))
+      .map(r => {
+        const menuRoute = r.children ? getChildIndexRoute(r.children) : r;
+        const children = r.children ? r.children.filter(child => child.path !== "") : false;
+        const item = createMenuItem(menuRoute, getItemPath(r, parentPath), opts.item);
+        if (opts.includeChildren && children.length) {
+          item.children = toMenuItems(children, item.path);
+        }
+        return item;
+      })
+      .sort(opts.sort);
+  };
+  return toMenuItems(routes);
 }
 
+/**
+ * Returns menu flat (no parent children)
+ */
+export function flattenMenu(menu) {
+  function flatten(items) {
+    const result = [];
+    for (const item of items) {
+      const newItem = { ...item };
+      delete newItem.children;
+      result.push(newItem);
+      if (item.children) {
+        result.push(...flatten(item.children));
+      }
+    }
+    return result;
+  }
+  return flatten(menu);
+} 
+
 /**
  * Print out a section's menu based on path
  * @param {*} routes All routes 
@@ -53,7 +107,6 @@ export function createSectionMenu(routes, sectionPath, options) {
   };
   const opts = Object.assign({}, defaults, options);
   const base = routes.find(r => r.path !== "/" && sectionPath.includes(r.path));
-  // Go through each item and 
   const getSection = (current, previous, path) => {
     if (current.children) {
       const child = current.children.find(c => c.path.includes(sectionPath));
@@ -74,20 +127,6 @@ export function createSectionMenu(routes, sectionPath, options) {
     .sort(opts.sort);
 }
 
-/**
- * For a given route this will return the route that renders. For routes without
- * children this is the route itself for those with children (first child with empty path)
- * @param {Object} route Route object to resolve
- * @returns {Object} Resolved route
- */
-// export function resolveRouteIndex(route) {
-//   if (route.children) {
-//     return getChildIndexRoute(route.children);
-//   } else {
-//     return route;
-//   }
-// }
-
 /**
  * For a given array of child routes return the index
  * @param {Array} children Children array of routes
@@ -96,6 +135,7 @@ export function createSectionMenu(routes, sectionPath, options) {
 export function getChildIndexRoute(children) {
   return children.find(r => r.path === "");
 }
+
 /**
  * Creates common menu item structure from route, pulls title and weight from meta (on route or index child)
  * @param {Object} route Route
@@ -115,9 +155,10 @@ export function createMenuItem(route, routePath = route.path, options) {
   if (opts.indexMeta && route.children) {
     meta = Object.assign({}, meta, getChildIndexRoute(route.children)?.meta);
   }
+  const routeWithMergedMeta = { ...route, meta };
   const item = { 
     path: routePath, 
-    title: meta?.title || "Missing Title",
+    title: getRouteTitle(routeWithMergedMeta, route) || "Missing Title",
     weight: meta?.weight || 0,
     meta
   };
@@ -126,23 +167,26 @@ export function createMenuItem(route, routePath = route.path, options) {
   }
   return item;
 }
+
 /**
- * Test if route is static (doesn't incude parameters)
+ * Test if route is static (doesn't include parameters)
  * @param {Object} route Route object to test
  * @returns {Boolean} Whether or not this route is static (not dynamic)
  */
 export function isStaticRoute(route) {
   return !route.path.includes("/:");
 }
+
 /**
  * 
  * @param {Object} route Route object to test
  * @returns {Boolean} Whether or not this route is a static base route
  */
 export function isStaticBaseRoute(route) {
-  const matches = route.path.match(/\//) || [];
+  const matches = route.path.match(/\//g) || [];
   return isStaticRoute(route) && matches.length === 1;
 }
+
 /**
  * Function to make normal <a> behave as router links instread of page reload
  * @param {Object} router Router instance (ie src/router) to push routes to
@@ -159,6 +203,7 @@ export function nativeLinkRouter(router, event) {
     }
   }
 }
+
 /**
  * Returns the child routes for base route
  * @param {Object} route Route Object
@@ -167,6 +212,7 @@ export function nativeLinkRouter(router, event) {
 export function $getRouteChildren(route, parent = $getParentRoute(route)) {
   return parent?.children;
 }
+
 /**
  * Returns the route's parent
  * @param {Object} route Route Object
@@ -216,4 +262,42 @@ export function $createSectionMenu(route, options) {
     .filter(includeIndex(opts.includeIndex))
     .map(r => createMenuItem(r, `${ parent.path }/${ r.path }`, opts.item))
     .sort(opts.sort);
-}
+}
+
+/**
+ * For a given $route, this will generate a breadcrumb trail.
+ * It iterates through `route.matched` to build the trail.
+ * - Falls back to `meta.title` (string or function).
+ * - Skips routes where `meta.breadcrumb` is set to `false`.
+ * - Avoids duplicate crumbs for nested routes with empty paths.
+ * @param {Object} route The Vue Router `$route` object.
+ * @returns {Array.<{title: String, to: Object, current: Boolean}>} An array of breadcrumb items.
+ */
+export function $createBreadcrumb(route) {
+  const { matched, path: currentPath } = route;
+  let prevPath;
+
+  const crumbs = matched.reduce((arr, match, index) => {
+    if (match.meta?.breadcrumb === false) {
+      return arr;
+    }
+
+    if (match.path === prevPath) {
+      return arr;
+    }
+    
+    const isLast = index === matched.length - 1;
+    const title = getRouteTitle(match, route) || "Missing Title";
+
+    arr.push({
+      title,
+      to: { path: isLast ? currentPath : match.path },
+      current: isLast,
+    });
+
+    prevPath = match.path;
+    return arr;
+  }, []);
+  
+  return crumbs;
+}

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@ulu/frontend-vue",
-  "version": "0.1.0-beta.3",
-  "description": "Frontend theming library (Vue)",
+  "version": "0.1.0-beta.31",
+  "description": "A modular and tree-shakeable Vue 3 component library for the Ulu frontend",
   "type": "module",
-  "files" : [
+  "files": [
     "lib",
-    "dist"
+    "dist",
+    "types"
   ],
   "module": "./lib/index.js",
   "exports": {
     ".": {
-      "import": "./lib/index.js"
+      "import": "./lib/index.js",
+      "types": "./types/index.d.ts"
     },
     "./dist": {
       "import": "./dist/frontend-vue.js"
@@ -18,17 +20,37 @@
     "./*": "./lib/*",
     "./scss": "./lib/_index.scss"
   },
+  "types": "./types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./types/*"
+      ]
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Jscherbe/frontend-vue.git"
   },
   "scripts": {
     "dev": "storybook dev -p 6006",
-    "docs:build": "storybook build -o docs --docs",
+    "docs:build": "storybook build -o docs",
     "build": "vite build",
-    "deploy": "npm run build && npm run docs:build"
+    "types": "npx tsc",
+    "deploy": "npm run types && npm run build && npm run docs:build",
+    "update-contexts": "rm -rf .ctx && mkdir -p .ctx/frontend && cp -R node_modules/@ulu/frontend/scss node_modules/@ulu/frontend/js .ctx/frontend/"
   },
-  "keywords": [],
+  "keywords": [
+    "vue",
+    "vue3",
+    "ui",
+    "components",
+    "component-library",
+    "design-system",
+    "ulu",
+    "frontend",
+    "scss"
+  ],
   "author": "Joseph Scherben <jscherbe@gmail.com>",
   "license": "MIT",
   "bugs": {
@@ -37,29 +59,31 @@
   "homepage": "https://github.com/Jscherbe/frontend-vue#readme",
   "peerDependencies": {
     "@headlessui/vue": "^1.7.23",
-    "@ulu/frontend": "^0.1.0-beta.94",
+    "@ulu/frontend": "^0.1.0-beta.104",
+    "@unhead/vue": "^2.0.11",
     "vue": "^3.5.17",
     "vue-router": "^4.5.1"
   },
   "optionalDependencies": {
-    "gsap": "^3.13.0",
     "fuse.js": "^6.6.2",
+    "gsap": "^3.13.0",
     "vue3-dropzone": "^2.2.1"
   },
   "dependencies": {
     "@floating-ui/vue": "^1.1.8",
     "@ulu/utils": "^0.0.30",
-    "lodash.clonedeep" : "^4.5.0"
+    "lodash-es": "^4.17.21"
   },
   "devDependencies": {
     "@fortawesome/fontawesome-svg-core": "^6.7.2",
     "@fortawesome/free-solid-svg-icons": "^6.7.2",
     "@fortawesome/vue-fontawesome": "^3.0.8",
     "@storybook/addon-docs": "^9.1.1",
-    "@storybook/addon-links": "^9.1.1",
     "@storybook/addon-essentials": "^9.0.0-alpha.12",
+    "@storybook/addon-links": "^9.1.1",
     "@storybook/vue3-vite": "^9.1.1",
-    "@ulu/frontend": "^0.1.0-beta.94",
+    "@ulu/frontend": "^0.1.0-beta.104",
+    "@unhead/vue": "^2.0.11",
     "@vitejs/plugin-vue": "^6.0.0",
     "ollama": "^0.5.16",
     "react": "^19.1.1",
@@ -67,6 +91,7 @@
     "sass-embedded": "^1.89.2",
     "storybook": "^9.1.1",
     "storybook-addon-vue-mdx": "^2.0.2",
+    "typescript": "^5.3.3",
     "vite": "^7.0.0",
     "vue-router": "^4.5.1"
   },

package/types/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./systems/index.js";
+//# sourceMappingURL=index.d.ts.map

package/types/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/components/index.js"],"names":[],"mappings":""}

package/types/components/systems/facets/_mock-data.d.ts

@@ -0,0 +1,18 @@
+export const initialMockFacets: {
+    name: string;
+    uid: string;
+    open: boolean;
+    children: {
+        uid: string;
+        label: string;
+    }[];
+}[];
+export const mockItems: {
+    id: number;
+    title: string;
+    description: string;
+    category: string[];
+    author: string[];
+    date: Date;
+}[];
+//# sourceMappingURL=_mock-data.d.ts.map

package/types/components/systems/facets/_mock-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_mock-data.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/_mock-data.js"],"names":[],"mappings":"AAAA;;;;;;;;IAwBE;AAEF;;;;;;;IAaE"}

package/types/components/systems/facets/useFacets.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A composable for handling client-side faceted search, filtering, and sorting.
+ * @param {import('vue').Ref<Array<Object>>} allItems - A Vue ref containing the full list of items to be processed.
+ * @param {Object} options - Configuration options for the composable.
+ * @param {Array} [options.initialFacets] - The initial configuration for the facets. Can be generated automatically if `facetFields` is provided.
+ * @param {Array} [options.facetFields] - A simpler configuration to automatically generate facets from items. Each item can have `uid`, `name`, `open`, `getValue` and `getLabel`.
+ * @param {String} [options.initialSearchValue=''] - The initial value for the search input.
+ * @param {String} [options.initialSortType='az'] - The initial sort type.
+ * @param {Boolean} [options.noDefaultSorts=false] - If true, the default 'A-Z' and 'Z-A' sorts will not be included.
+ * @param {Object} [options.extraSortTypes={}] - Additional sort types to be merged with the default ones.
+ * @param {Object} [options.searchOptions={}] - Configuration options for Fuse.js.
+ * @param {Function} [options.getItemFacet] - A function to retrieve facet information from an item. Should always return an array of values.
+ * @param {Function} [options.getSortValue] - A function to get the value to sort by from an item.
+ */
+export function useFacets(allItems: import("vue").Ref<Array<any>>, options?: {
+    initialFacets?: any[];
+    facetFields?: any[];
+    initialSearchValue?: string;
+    initialSortType?: string;
+    noDefaultSorts?: boolean;
+    extraSortTypes?: any;
+    searchOptions?: any;
+    getItemFacet?: Function;
+    getSortValue?: Function;
+}): {
+    facets: import("vue").Ref<any, any>;
+    searchValue: import("vue").Ref<string, string>;
+    selectedSort: import("vue").Ref<string, string>;
+    sortTypes: import("vue").ComputedRef<any>;
+    displayItems: import("vue").ComputedRef<any>;
+    selectedFacets: import("vue").ComputedRef<any[]>;
+    clearFilters: () => void;
+    handleFacetChange: ({ groupUid, facetUid, selected }: {
+        groupUid: any;
+        facetUid: any;
+        selected: any;
+    }) => void;
+};
+//# sourceMappingURL=useFacets.d.ts.map

package/types/components/systems/facets/useFacets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFacets.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/useFacets.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;GAaG;AACH,oCAZW,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,KAAQ,CAAC,YAExC;IAAwB,aAAa;IACb,WAAW;IACV,kBAAkB;IAClB,eAAe;IACd,cAAc;IACf,cAAc;IACd,aAAa;IACX,YAAY;IACZ,YAAY;CACzC;;;;;;;;;;;;;EAiLA"}

package/types/components/systems/index.d.ts

@@ -0,0 +1,2 @@
+export { useFacets } from "./facets/useFacets.js";
+//# sourceMappingURL=index.d.ts.map

package/types/components/systems/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/components/systems/index.js"],"names":[],"mappings":""}

package/types/components/systems/scroll-anchors/symbols.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Symbol for register provide/inject
+ */
+export const REGISTER: any;
+export const UNREGISTER: any;
+export const SECTIONS: any;
+//# sourceMappingURL=symbols.d.ts.map

package/types/components/systems/scroll-anchors/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/scroll-anchors/symbols.js"],"names":[],"mappings":"AAAA;;GAEG;AACH,2BAAiC;AACjC,6BAAmC;AACnC,2BAAiC"}

package/types/composables/index.d.ts

@@ -0,0 +1,8 @@
+export { useIcon } from "./useIcon.js";
+export { useModifiers } from "./useModifiers.js";
+export { useWindowResize } from "./useWindowResize.js";
+export { useRequiredInject } from "./useRequiredInject.js";
+export { useBreakpointManager } from "./useBreakpointManager.js";
+export { usePagination } from "./usePagination.js";
+export { useDocumentTitle } from "./useDocumentTitle.js";
+//# sourceMappingURL=index.d.ts.map

package/types/composables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/composables/index.js"],"names":[],"mappings":""}

package/types/composables/useBreakpointManager.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Use the CssBreakpoints module in Vue
+ * - Normally use only once, unless you have different sets of breakpoints
+ * @param {Object} options Configuration options overrides
+ * @return {Object} { manager, active, direction } (all are null in SSR environment until init)
+ */
+export function useBreakpointManager(options: any): any;
+//# sourceMappingURL=useBreakpointManager.d.ts.map

package/types/composables/useBreakpointManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBreakpointManager.d.ts","sourceRoot":"","sources":["../../lib/composables/useBreakpointManager.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,wDAyCC"}

package/types/composables/useDocumentTitle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A composable to manage the document title.
+ *
+ * When called with a `title` option, it sets a dynamic title for the current page.
+ * This is for use within specific components.
+ *
+ * When called without a `title` option (typically in App.vue), it manages the
+ * document title for the whole app, using titles from components or route meta.
+ *
+ * @param {object} options
+ * @param {import('vue').Ref<string> | string} [options.title] - The dynamic title to set for the current page.
+ * @param {string} [options.titleTemplate='%s'] - The template for the document title, e.g., '%s | My Site'.
+ * @param {Function} [options.useRoute=defaultUseRoute] - Injectable `useRoute` for testing.
+ * @param {Function} [options.useHead=defaultUseHead] - Injectable `useHead` for testing.
+ */
+export function useDocumentTitle(options?: {
+    title?: import("vue").Ref<string> | string;
+    titleTemplate?: string;
+    useRoute?: Function;
+    useHead?: Function;
+}): void;
+//# sourceMappingURL=useDocumentTitle.d.ts.map

package/types/composables/useDocumentTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocumentTitle.d.ts","sourceRoot":"","sources":["../../lib/composables/useDocumentTitle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,2CALG;IAAqD,KAAK,GAAlD,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM;IACjB,aAAa,GAA9B,MAAM;IACa,QAAQ;IACR,OAAO;CACpC,QAsCA"}

package/types/composables/useIcon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility composable for handling and formatting icon props for UluIcon.
+ * @returns {Object} An object with utility functions { getIconProps, getClassesFromDefinition }
+ */
+export function useIcon(): any;
+//# sourceMappingURL=useIcon.d.ts.map

package/types/composables/useIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIcon.d.ts","sourceRoot":"","sources":["../../lib/composables/useIcon.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,+BAyDC"}

package/types/composables/useModifiers.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A composable to manage and resolve BEM style modifiers for a component,
+ * combining user-passed modifiers with internally derived conditional modifiers.
+ *
+ * @param {object} options - The options for the composable.
+ * @param {object} options.props - The component's props object. (Must contain a 'modifiers' prop if user-passed modifiers are expected)
+ * @param {string | import('vue').Ref<string>} options.baseClass - The base CSS class name for the component (e.g., 'modal').
+ * Can be a string or a ref to a string.
+ * @param {string | string[] | Object.<string, any> | import('vue').ComputedRef<string | string[] | Object.<string, any>>} [options.internal={}] -
+ * A flexible input for component's internal modifiers. Can be a string, array of strings/objects, or an object mapping modifier names to conditions.
+ * @returns {object} An object containing the computed property `resolvedModifiers`
+ *
+ * @example
+ * // In MyComponent.vue:
+ * <template>
+ * <div :class="[resolvedModifiers, 'other-class']"></div>
+ * </template>
+ *
+ * <script>
+ * import { computed, ref } from 'vue';
+ * import { useModifiers } from './composables/useModifiers.js'; // Adjust path
+ *
+ * export default {
+ *   props: {
+ *     variant: String, // e.g., 'primary', 'secondary'
+ *     isActive: Boolean,
+ *     modifiers: [String, Array, Object] // User-passed modifiers
+ *   },
+ *   setup(props) {
+ *     const isHovered = ref(false);
+ *
+ *     // Define component-internal modifiers based on props or local state
+ *     const internalModifiers = computed(() => ({
+ *       [props.variant]: !!props.variant, // Add 'primary' or 'secondary' if prop exists
+ *       'active': props.isActive, // Add 'active' if isActive prop is true
+ *       'hovered': isHovered.value, // Add 'hovered' if local state is true
+ *       'default': !props.variant && !props.isActive // Add 'default' if no variant/active
+ *     }));
+ *
+ *     // Use the composable to get the combined modifier classes
+ *     const { resolvedModifiers } = useModifiers({
+ *       props: props, // Pass component props for 'modifiers' prop
+ *       baseClass: 'button', // The BEM block name
+ *       internal: internalModifiers // The computed internal modifiers
+ *     });
+ *
+ *     return { resolvedModifiers, isHovered };
+ *   }
+ * };
+ * </script>
+ *
+ * // Resulting class examples for 'my-component':
+ * // <MyComponent />                       => class="my-component my-component--default"
+ * // <MyComponent variant="primary" />     => class="my-component my-component--primary"
+ * // <MyComponent isActive />              => class="my-component my-component--active"
+ * // <MyComponent modifiers="condensed" /> => class="my-component my-component--default my-component--condensed"
+ * // <MyComponent variant="secondary" :isActive="true" modifiers="round" />
+ * //   => class="my-component my-component--secondary my-component--active my-component--round"
+ */
+export function useModifiers({ props, baseClass, internal }: {
+    props: object;
+    baseClass: string | import("vue").Ref<string>;
+    internal?: string | string[] | {
+        [x: string]: any;
+    } | import("vue").ComputedRef<string | string[] | {
+        [x: string]: any;
+    }>;
+}): object;
+//# sourceMappingURL=useModifiers.d.ts.map

package/types/composables/useModifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModifiers.d.ts","sourceRoot":"","sources":["../../lib/composables/useModifiers.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,6DAtDG;IAAwB,KAAK,EAArB,MAAM;IACsC,SAAS,EAArD,MAAM,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC;IAEuF,QAAQ,GAAjI,MAAM,GAAG,MAAM,EAAE,GAAG;YAAQ,MAAM,GAAE,GAAG;KAAC,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG;YAAQ,MAAM,GAAE,GAAG;KAAC,CAAC;CAEtH,GAAU,MAAM,CA0ElB"}

package/types/composables/usePageTitle.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A composable to set the title for the current page/route from within its component.
+ * This provides a single source of truth for a page's title, which can be
+ * consumed by various parts of the application (e.g., breadcrumbs, document title).
+ * @param {import('vue').Ref<string> | string} title The title to set for the current page. Can be a ref, computed, or a plain string.
+ * @param {{ useRoute: Function }} options For dependency injection in tests/stories.
+ */
+export function usePageTitle(title: import("vue").Ref<string> | string, { useRoute }?: {
+    useRoute: Function;
+}): void;
+/**
+ * Gets the dynamically set page title for a given path.
+ * For internal use by consumers like breadcrumb or document title utilities.
+ * @param {string} path The route path to look up.
+ * @returns {string | undefined}
+ */
+export function getPageTitle(path: string): string | undefined;
+export const pageTitles: {};
+//# sourceMappingURL=usePageTitle.d.ts.map

package/types/composables/usePageTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePageTitle.d.ts","sourceRoot":"","sources":["../../lib/composables/usePageTitle.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,oCAHW,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,iBAClC;IAAE,QAAQ,WAAU;CAAE,QAchC;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,GAAG,SAAS,CAI9B;AA/BD,4BAAuC"}

package/types/composables/usePagination.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A Vue composable for handling pagination logic.
+ * It interacts with vue-router to keep the current page in the URL query string.
+ *
+ * @param {import('vue').Ref<Array<any>>} items - A ref containing the full list of items to be paginated.
+ * @param {number} itemsPerPage - The number of items to display per page.
+ * @returns {{
+ *   currentPage: import('vue').ComputedRef<number>,
+ *   totalPages: import('vue').ComputedRef<number>,
+ *   paginatedItems: import('vue').ComputedRef<Array<any>>,
+ *   pagerItems: import('vue').ComputedRef<object|null>,
+ *   pagerEllipses: import('vue').ComputedRef<{previous: boolean, next: boolean}>
+ * }} - An object containing reactive properties for pagination.
+ */
+export function usePagination(items: import("vue").Ref<Array<any>>, itemsPerPage: number): {
+    currentPage: import("vue").ComputedRef<number>;
+    totalPages: import("vue").ComputedRef<number>;
+    paginatedItems: import("vue").ComputedRef<Array<any>>;
+    pagerItems: import("vue").ComputedRef<object | null>;
+    pagerEllipses: import("vue").ComputedRef<{
+        previous: boolean;
+        next: boolean;
+    }>;
+};
+//# sourceMappingURL=usePagination.d.ts.map

package/types/composables/usePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePagination.d.ts","sourceRoot":"","sources":["../../lib/composables/usePagination.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,qCAVW,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,gBAC7B,MAAM,GACJ;IACR,WAAW,EAAE,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/C,UAAU,EAAE,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9C,cAAc,EAAE,OAAO,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACtD,UAAU,EAAE,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,GAAC,IAAI,CAAC,CAAC;IACnD,aAAa,EAAE,OAAO,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,CAAC,CAAA;CAC7E,CA0GH"}

package/types/composables/useRequiredInject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Injects a dependency from a plugin (or other required inject) and throws an error if it's not available.
+ *
+ * @param {string} key - The injection key (e.g., 'uluBreakpointManager').
+ * @returns The injected value.
+ */
+export function useRequiredInject(key: string): {};
+//# sourceMappingURL=useRequiredInject.d.ts.map

package/types/composables/useRequiredInject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRequiredInject.d.ts","sourceRoot":"","sources":["../../lib/composables/useRequiredInject.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,uCAHW,MAAM,MAchB"}

package/types/composables/useWindowResize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Composable function
+ * @return {Object} Contains reactive 'resizing' and two methods for calling callbacks (onResizeStart, onResizeEnd)
+ */
+export function useWindowResize(): any;
+//# sourceMappingURL=useWindowResize.d.ts.map

package/types/composables/useWindowResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWindowResize.d.ts","sourceRoot":"","sources":["../../lib/composables/useWindowResize.js"],"names":[],"mappings":"AAiDA;;;GAGG;AACH,uCAUC"}