@xy-planning-network/trees 0.9.1 → 0.9.2-rc1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xy-planning-network/trees",
-  "version": "0.9.1",
+  "version": "0.9.2-rc1",
   "description": "",
   "license": "MIT",
   "repository": "github:xy-planning-network/trees",

package/types/composables/index.d.ts

@@ -7,5 +7,9 @@ import { useFlashes, useAppFlashes, useAppFlasher } from "./useFlashes";
 import type { FlashMessage, FlashType, FlashStore, Flasher } from "./useFlashes";
 export type { FlashMessage, FlashType, FlashStore, Flasher };
 export { useFlashes, useAppFlashes, useAppFlasher };
+import type { URLParams, URLParamValue, UseTabHistoryOpts } from "./nav";
+export type { URLParams, URLParamValue, UseTabHistoryOpts };
+import { useUrlSearchParams, useTabHistory } from "./nav";
+export { useUrlSearchParams, useTabHistory };
 import { useSpinnerDisplay, useAppSpinner } from "./useSpinner";
 export { useSpinnerDisplay, useAppSpinner };

package/types/composables/nav.d.ts

@@ -1,4 +1,4 @@
-import type { Component, FunctionalComponent, RenderFunction } from "vue";
+import { Component, FunctionalComponent, MaybeRef, RenderFunction } from "vue";
 export interface Item {
     icon?: Component | RenderFunction;
     name: string;
@@ -18,3 +18,122 @@ export interface ActionItem {
     label: string;
     show?: boolean | ((...args: any[]) => boolean);
 }
+export interface UseTabHistoryOpts {
+    /**
+     * The initial value of activeTab.
+     * The default value is tabs[0].value.
+     *
+     * When a valid tab value is found on window.location.search
+     * it will replace the initial value.
+     */
+    initial?: string;
+    /**
+     * The param name to use on window.location.search.
+     * The default is "tab".
+     */
+    paramName?: string;
+}
+/**
+ * useTabHistory
+ *
+ * Example Usage:
+ *
+ * const {activeTab, tabs} = useTabHistory([{label: "Tab One", value: "tab-1"}, {label: "Tab Two", value: "tab-2"}]})
+ *
+ * <Tabs v-model="activeTab" :tabs="tabs" />
+ *
+ * <div v-if="activeTab === 'tab-1'">Tab 1 Content</div>
+ * <div v-if="activeTab === 'tab-2'">Tab 2 Content</div>
+ *
+ * @param opts UseTabHistoryOpts
+ * @return {activeTab: Ref<string>, tabs: Ref<{labe: string, value: string}[]>}
+ */
+export declare const useTabHistory: (initialTabs: MaybeRef<{
+    label: string;
+    value: string;
+}[]>, opts?: UseTabHistoryOpts) => {
+    activeTab: import("vue").Ref<string>;
+    tabs: import("vue").Ref<{
+        label: string;
+        value: string;
+    }[] | {
+        label: string;
+        value: string;
+    }[]>;
+};
+/**
+ * URLParamValue is the set of value types that are
+ * currently spec'd to be parsed into a query string.
+ */
+export type URLParamValue = string | number | boolean | null | undefined | string[] | number[];
+/**
+ * URLParams generic serves as a type constraint ensuring that
+ * the search params record used only contains fields that are
+ * currently spec'd to be parsed into a query string. See: URLParamValue
+ *
+ * Example:
+ *
+ * interface SearchParams {
+ *    // All Good!
+ *    q: string
+ *    count: number
+ *    isActive: boolean
+ *    terms: string[]
+ *    bucketOfNumbers: number[]
+ *
+ *    // Nope!
+ *    nested: {
+ *        qTwo: string
+ *    }
+ * }
+ */
+export type URLParams<T> = {
+    [P in keyof T]: T[P] extends URLParamValue ? T[P] : never;
+};
+/**
+ * useUrlSearchParams accepts an initial set of search query params
+ * in the shape of Record<string, URLParamValue> and tracks the values
+ * of each param on window.location.search.
+ *
+ * This is a one-way sync where non-nullish, non-falsey values are popped
+ * onto window.location.search as they are mutated.  The initial values are not read
+ * from an existing query string on window.location.search as each values
+ * type cannot be inferred safely.
+ *
+ * This composable ignores query params that may already exist on window.location.search
+ * leaving the intact as much as possible, since it's not possible to determine where they
+ * came from or what function they may serve.
+ *
+ * The return value is a ref of the initial set of params.
+ *
+ * Example Usage:
+ * interface SearchParams {
+ *    q: string
+ *    isActive: boolean
+ * }
+ *
+ * // NOTE: initial params values should come from the
+ * // server in the form of a page prop. Though some
+ * // exceptions may exist.
+ * const props = defineProps<{
+ *    initialParams: SearchParams
+ * }>
+ *
+ * const searchParams = useUrlSearchParams(props.initialParam)
+ *
+ * <BaseInput v-model="searchParams.q" label="Search" type="search" />
+ * <Checkbox v-model="searchParams.isActive" label="Is Active" />
+ *
+ *  When q = "jimothy bobbitz" and isActive = false
+ * /path?q=jimothy+bobbitz
+ *
+ * When q = "jimothy bobbitz" and isActive = true
+ * /path?q=jimothy+bobbitz&isActive=true
+ *
+ * * When q = "" and isActive = false
+ * /path
+ *
+ * @param initial any Record<string, URLParamValue> like interface
+ * @return Ref<T>
+ */
+export declare const useUrlSearchParams: <T>(initial: URLParams<T>) => import("vue").Ref<import("vue").UnwrapRef<URLParams<T>>>;

package/types/helpers/Slots.d.ts

@@ -0,0 +1,2 @@
+import { Slot } from "vue";
+export declare function hasSlotContent(slot: Slot | undefined, slotProps?: {}): boolean;

package/types/lib-components/lists/StaticTable.vue.d.ts

@@ -0,0 +1,21 @@
+import type { TableColumn, TableRow } from "../../composables/table";
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    columns: TableColumn<TableRow>[];
+    rows: TableRow[];
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    columns?: unknown;
+    rows?: unknown;
+} & {
+    columns: TableColumn<TableRow>[];
+    rows: TableRow[];
+} & {}>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/types/lib-components/lists/StaticTableActionSlot.vue.d.ts

@@ -0,0 +1,27 @@
+import * as TableTypes from "../../composables/table";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    tableData: Omit<TableTypes.Static, "currentUser">;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    tableData?: unknown;
+} & {
+    tableData: Omit<TableTypes.Static, "currentUser">;
+} & {}>, {}>, {
+    actions: (_: {
+        row: Record<string, unknown>;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/lib-components/lists/Table.vue.d.ts

@@ -0,0 +1,39 @@
+import * as TableTypes from "../../composables/table";
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    clickable?: boolean | undefined;
+    loader?: boolean | undefined;
+    tableData: TableTypes.Dynamic;
+}>, {
+    clickable: boolean;
+    loader: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    handleClick: (v: any) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    tableData?: unknown;
+    clickable?: unknown;
+    loader?: unknown;
+} & {
+    tableData: TableTypes.Dynamic;
+    clickable: boolean;
+    loader: boolean;
+} & {}> & {
+    onHandleClick?: ((v: any) => any) | undefined;
+}, {
+    clickable: boolean;
+    loader: boolean;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
+        default: D[K];
+    } : P[K];
+};

package/types/lib-components/navigation/ActionsDropdownCallback.vue.d.ts

@@ -0,0 +1,18 @@
+import type { ActionMenuItemCallback } from "../../composables/nav";
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    items: ActionMenuItemCallback[];
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    items?: unknown;
+} & {
+    items: ActionMenuItemCallback[];
+} & {}>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/types/lib-components/navigation/ActionsDropdownEmit.vue.d.ts

@@ -0,0 +1,22 @@
+import type { ActionMenuEmit } from "../../composables/nav";
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    items: ActionMenuEmit[];
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (v: string) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    items?: unknown;
+} & {
+    items: ActionMenuEmit[];
+} & {}> & {
+    onClick?: ((v: string) => any) | undefined;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};