nuxt-ui-tools 0.1.0

package/dist/runtime/query-state/composables.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Vue composables for URL query state management.
+ *
+ * - useQueryState:   single param ↔ typed ref
+ * - useQueryStates:  multiple params ↔ single reactive object, batched writes
+ * - dynamicQueryState: factory for dynamic key sets (e.g. filters)
+ *
+ * All backed by QueryStateClient for cache + microtask batching.
+ * Uses shallowRef internally to avoid deep reactive proxying.
+ */
+import { type WritableComputedRef } from 'vue';
+import { QueryStateClient, type HistoryMode } from './client.js';
+import type { QueryCodec } from './codecs.js';
+/**
+ * Pre-register a query-state client for a router instance.
+ *
+ * This is useful from app plugins when you want one shared client instance with
+ * custom defaults or devtools wiring before composables run.
+ *
+ * @example
+ * ```ts
+ * const client = new QueryStateClient({ router, defaultHistoryMode: 'replace' })
+ * registerQueryStateClient(router, client)
+ * ```
+ */
+export declare function registerQueryStateClient(router: object, client: QueryStateClient): void;
+/**
+ * Returns the shared query-state client for the current router.
+ *
+ * If no client has been registered yet, this lazily creates one and wires route
+ * synchronization so external navigations update active query-state consumers.
+ *
+ * @example
+ * ```ts
+ * const client = useQueryStateClient({ defaultHistoryMode: 'push' })
+ * client.set('page', '2')
+ * ```
+ */
+export declare function useQueryStateClient(options?: {
+    /** History mode used by the lazily created client when individual writes omit one. */
+    defaultHistoryMode?: HistoryMode;
+}): QueryStateClient;
+type ResolveDefaultedValue<TValue, TDefault> = undefined extends TDefault ? TValue : Exclude<TValue, undefined>;
+type UseQueryStateBaseOptions<TValue> = {
+    /** Query-string key to read from and write to. */
+    key: string;
+    /** Codec that maps between raw query values and the typed runtime value. */
+    codec: QueryCodec<TValue>;
+    /** Remove the key when the serialized value matches `defaultValue`. Defaults to `true`. */
+    omitDefault?: boolean;
+    /** Override the router history mode for writes from this state. */
+    historyMode?: HistoryMode;
+};
+/**
+ * Options for a single typed query-state binding.
+ *
+ * When `defaultValue` excludes `undefined`, the returned ref is narrowed so
+ * downstream code can treat missing or invalid query values as already resolved.
+ */
+export type UseQueryStateOptions<TValue, TDefault = TValue> = UseQueryStateBaseOptions<TValue> & {
+    /** Fallback used when the key is missing or the codec returns `undefined`. */
+    defaultValue: TDefault;
+};
+export declare function useQueryState<TValue>(options: UseQueryStateBaseOptions<TValue> & {
+    defaultValue: undefined;
+}): WritableComputedRef<TValue>;
+export declare function useQueryState<TValue, TDefault extends Exclude<TValue, undefined>>(options: UseQueryStateBaseOptions<TValue> & {
+    defaultValue: TDefault;
+}): WritableComputedRef<Exclude<TValue, undefined>>;
+declare const DYNAMIC_MARKER: unique symbol;
+/**
+ * Configuration for a grouped query-state field whose URL keys are discovered at
+ * runtime from a definition list.
+ *
+ * This is useful for abstractions like dynamic filters where the property shape
+ * is stable for consumers, but the concrete query keys depend on runtime schema.
+ */
+export interface DynamicQueryStateOptions<TDefinition, TValue> {
+    /** URL prefix for all keys this dynamic state owns, relative to the parent `prefix`. */
+    urlPrefix: string;
+    /** Returns the current definitions that determine which query keys exist. */
+    definitions: () => TDefinition[];
+    /**
+     * For one runtime definition, return every query key it may occupy together
+     * with the codec that should parse and serialize that key.
+     */
+    resolve: (definition: TDefinition) => Array<{
+        urlKey: string;
+        codec: QueryCodec<any>;
+    }>;
+    /** Build the consumer-facing value from the parsed query entries and current definitions. */
+    parse: (entries: ReadonlyMap<string, unknown>, definitions: TDefinition[]) => TValue;
+    /**
+     * Map the consumer-facing value back into query entries.
+     *
+     * Use `null` values in the returned map to clear individual query keys.
+     */
+    serialize: (value: TValue, definitions: TDefinition[]) => Map<string, unknown>;
+    /** Value returned when no relevant query keys are currently present. */
+    defaultValue: TValue;
+}
+export interface DynamicQueryStateDef<TValue> {
+    [DYNAMIC_MARKER]: true;
+    _options: DynamicQueryStateOptions<any, TValue>;
+}
+/**
+ * Declares a dynamic grouped query-state field for use inside `useQueryStates(...)`.
+ *
+ * The returned marker object is schema metadata, not reactive state by itself.
+ *
+ * @example
+ * ```ts
+ * const filters = dynamicQueryState({
+ *   urlPrefix: 'filters',
+ *   definitions: () => filterDefinitions.value,
+ *   resolve: (definition) => [{ urlKey: definition.key, codec: stringCodec }],
+ *   parse: (entries) => Array.from(entries.entries()),
+ *   serialize: (value) => new Map(value),
+ *   defaultValue: [],
+ * })
+ * ```
+ */
+export declare function dynamicQueryState<TDefinition, TValue>(options: DynamicQueryStateOptions<TDefinition, TValue>): DynamicQueryStateDef<TValue>;
+/**
+ * Static query-state definition used inside `useQueryStates(...)`.
+ *
+ * Each property maps one state field to one query-string key.
+ */
+export interface StaticQueryStateOptions<TValue = any, TDefault = TValue> {
+    /** Codec used to parse the raw query value and serialize writes back to the URL. */
+    codec: QueryCodec<TValue>;
+    /** Fallback used when the query key is missing or the codec returns `undefined`. */
+    defaultValue: TDefault;
+    /** Override the URL key for this property. Defaults to the property name. */
+    urlKey?: string;
+    /** Remove the key when the serialized value matches `defaultValue`. Defaults to `true`. */
+    omitDefault?: boolean;
+    /** Override the history mode for this property when `useQueryStates(...)` writes. */
+    historyMode?: HistoryMode;
+}
+/**
+ * One schema entry accepted by `useQueryStates(...)`.
+ *
+ * Use a static entry for one-to-one property mappings, or `dynamicQueryState(...)`
+ * when one property owns a runtime-defined set of query keys.
+ */
+export type QueryStatesSchemaEntry<TValue = any, TDefault = TValue> = StaticQueryStateOptions<TValue, TDefault> | DynamicQueryStateDef<TValue>;
+/**
+ * Schema accepted by `useQueryStates(...)`.
+ *
+ * Each object key becomes a property on the returned writable computed state.
+ */
+export type QueryStatesSchema = Record<string, QueryStatesSchemaEntry>;
+type InferEntryValue<E> = E extends DynamicQueryStateDef<infer TValue> ? TValue : E extends StaticQueryStateOptions<infer TValue, infer TDefault> ? ResolveDefaultedValue<TValue, TDefault> : never;
+type QueryStatesValues<T extends QueryStatesSchema> = {
+    [K in keyof T]: InferEntryValue<T[K]>;
+};
+export interface UseQueryStatesOptions<T extends QueryStatesSchema> {
+    /** Optional prefix prepended to every static and dynamic query key in this schema. */
+    prefix?: string;
+    /** Schema describing the typed grouped state and how each property maps to the URL. */
+    schema: T;
+    /** Default history mode used when the grouped state writes to the router. */
+    historyMode?: HistoryMode;
+}
+/**
+ * Binds a schema of query-string keys to one writable computed object.
+ *
+ * Static entries map one property to one query key. Dynamic entries let one
+ * property own a runtime-discovered set of query keys while still participating
+ * in the same batched read/write flow.
+ *
+ * @example
+ * ```ts
+ * const pagination = useQueryStates({
+ *   prefix: 'users',
+ *   schema: {
+ *     page: { codec: numberCodec, defaultValue: 1 },
+ *     pageSize: { codec: numberCodec, defaultValue: 20, urlKey: 'size' },
+ *   },
+ * })
+ * ```
+ */
+export declare function useQueryStates<T extends QueryStatesSchema>(options: UseQueryStatesOptions<T>): WritableComputedRef<QueryStatesValues<T>>;
+export {};

package/dist/runtime/query-state/composables.js

@@ -0,0 +1,191 @@
+import { computed, onScopeDispose, shallowRef } from "vue";
+import { useRouter } from "vue-router";
+import { QueryStateClient } from "./client.js";
+const clientRegistry = /* @__PURE__ */ new WeakMap();
+export function registerQueryStateClient(router, client) {
+  clientRegistry.set(router, client);
+}
+export function useQueryStateClient(options) {
+  const router = useRouter();
+  let client = clientRegistry.get(router);
+  if (!client) {
+    client = new QueryStateClient({
+      router,
+      defaultHistoryMode: options?.defaultHistoryMode
+    });
+    clientRegistry.set(router, client);
+    router.afterEach(() => {
+      client.syncFromRoute();
+    });
+  }
+  return client;
+}
+export function useQueryState(options) {
+  const client = useQueryStateClient();
+  const { key, codec, defaultValue, historyMode } = options;
+  const omitDefault = options.omitDefault ?? true;
+  const internal = shallowRef(readFromClient());
+  function readFromClient() {
+    const raw = client.get(key);
+    if (raw == null) return defaultValue;
+    const parsed = codec.parse(raw);
+    return parsed === void 0 ? defaultValue : parsed;
+  }
+  function writeToClient(value) {
+    const serialized = codec.serialize(value);
+    const shouldOmit = omitDefault && serialized === codec.serialize(defaultValue);
+    client.set(key, shouldOmit ? null : serialized, historyMode);
+  }
+  const unsubscribe = client.subscribe((changedKey, rawValue) => {
+    if (changedKey !== key) return;
+    internal.value = rawValue == null ? defaultValue : (() => {
+      const parsed = codec.parse(rawValue);
+      return parsed === void 0 ? defaultValue : parsed;
+    })();
+  });
+  onScopeDispose(unsubscribe);
+  return computed({
+    get: () => internal.value,
+    set: (value) => {
+      internal.value = value;
+      writeToClient(value);
+    }
+  });
+}
+const DYNAMIC_MARKER = Symbol("dynamicQueryState");
+export function dynamicQueryState(options) {
+  return {
+    [DYNAMIC_MARKER]: true,
+    _options: options
+  };
+}
+function isDynamicDef(value) {
+  return value != null && typeof value === "object" && DYNAMIC_MARKER in value;
+}
+export function useQueryStates(options) {
+  const client = useQueryStateClient();
+  const { schema, historyMode, prefix } = options;
+  const keys = Object.keys(schema);
+  const staticKeys = [];
+  const dynamicKeys = [];
+  const staticUrlKeys = /* @__PURE__ */ new Map();
+  for (const k of keys) {
+    const entry = schema[k];
+    if (isDynamicDef(entry)) {
+      dynamicKeys.push(k);
+    } else {
+      staticKeys.push(k);
+      const def = entry;
+      const urlSegment = def.urlKey ?? k;
+      staticUrlKeys.set(k, prefix ? `${prefix}.${urlSegment}` : urlSegment);
+    }
+  }
+  const internal = shallowRef(readAll());
+  function readStatic(propKey) {
+    const def = schema[propKey];
+    const urlKey = staticUrlKeys.get(propKey);
+    const raw = client.get(urlKey);
+    if (raw == null) return def.defaultValue;
+    const parsed = def.codec.parse(raw);
+    return parsed === void 0 ? def.defaultValue : parsed;
+  }
+  function readDynamic(propKey) {
+    const dynDef = schema[propKey]._options;
+    const definitions = dynDef.definitions();
+    if (!definitions.length) return dynDef.defaultValue;
+    const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
+    const entries = /* @__PURE__ */ new Map();
+    for (const def of definitions) {
+      const resolvedKeys = dynDef.resolve(def);
+      for (const { urlKey, codec } of resolvedKeys) {
+        const fullKey = `${fullPrefix}.${urlKey}`;
+        const raw = client.get(fullKey);
+        if (raw != null && raw !== "") {
+          entries.set(urlKey, codec.parse(raw));
+        }
+      }
+    }
+    if (entries.size === 0) return dynDef.defaultValue;
+    return dynDef.parse(entries, definitions);
+  }
+  function writeDynamic(propKey, value) {
+    const dynDef = schema[propKey]._options;
+    const definitions = dynDef.definitions();
+    const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
+    const updates = [];
+    for (const def of definitions) {
+      const resolvedKeys = dynDef.resolve(def);
+      for (const { urlKey } of resolvedKeys) {
+        updates.push({ key: `${fullPrefix}.${urlKey}`, value: null });
+      }
+    }
+    const serialized = dynDef.serialize(value, definitions);
+    for (const [urlKey, val] of serialized) {
+      const fullKey = `${fullPrefix}.${urlKey}`;
+      let codec;
+      for (const def of definitions) {
+        const resolved = dynDef.resolve(def);
+        const match = resolved.find((r) => r.urlKey === urlKey);
+        if (match) {
+          codec = match.codec;
+          break;
+        }
+      }
+      if (codec && val != null) {
+        const existing = updates.findIndex((u) => u.key === fullKey);
+        const serializedValue = codec.serialize(val);
+        if (existing >= 0) {
+          updates[existing].value = serializedValue;
+        } else {
+          updates.push({ key: fullKey, value: serializedValue });
+        }
+      }
+    }
+    return updates;
+  }
+  function readAll() {
+    const result = {};
+    for (const k of staticKeys) result[k] = readStatic(k);
+    for (const k of dynamicKeys) result[k] = readDynamic(k);
+    return result;
+  }
+  function writeAll(values) {
+    const updates = [];
+    for (const k of staticKeys) {
+      const def = schema[k];
+      const urlKey = staticUrlKeys.get(k);
+      const value = values[k];
+      const serialized = def.codec.serialize(value);
+      const omit = (def.omitDefault ?? true) && serialized === def.codec.serialize(def.defaultValue);
+      updates.push({ key: urlKey, value: omit ? null : serialized });
+    }
+    for (const k of dynamicKeys) {
+      const dynUpdates = writeDynamic(k, values[k]);
+      updates.push(...dynUpdates);
+    }
+    client.setBatch(updates, historyMode);
+  }
+  const allStaticUrlKeyValues = new Set(staticUrlKeys.values());
+  const unsubscribe = client.subscribe((changedKey) => {
+    if (allStaticUrlKeyValues.has(changedKey)) {
+      internal.value = readAll();
+      return;
+    }
+    for (const k of dynamicKeys) {
+      const dynDef = schema[k]._options;
+      const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
+      if (changedKey.startsWith(fullPrefix + ".")) {
+        internal.value = readAll();
+        return;
+      }
+    }
+  });
+  onScopeDispose(unsubscribe);
+  return computed({
+    get: () => internal.value,
+    set: (value) => {
+      internal.value = value;
+      writeAll(value);
+    }
+  });
+}

package/dist/runtime/query-state/index.d.ts

@@ -0,0 +1,3 @@
+export { type QueryCodec, stringCodec, numberCodec, booleanCodec, dateISOCodec, createEnumCodec, createArrayCodec, } from './codecs.js';
+export { QueryStateClient, type HistoryMode, type QueryStateClientOptions } from './client.js';
+export { registerQueryStateClient, useQueryStateClient, useQueryState, useQueryStates, dynamicQueryState, type StaticQueryStateOptions, type QueryStatesSchemaEntry, type QueryStatesSchema, type UseQueryStateOptions, type UseQueryStatesOptions, type DynamicQueryStateOptions, } from './composables.js';

package/dist/runtime/query-state/index.js

@@ -0,0 +1,16 @@
+export {
+  stringCodec,
+  numberCodec,
+  booleanCodec,
+  dateISOCodec,
+  createEnumCodec,
+  createArrayCodec
+} from "./codecs.js";
+export { QueryStateClient } from "./client.js";
+export {
+  registerQueryStateClient,
+  useQueryStateClient,
+  useQueryState,
+  useQueryStates,
+  dynamicQueryState
+} from "./composables.js";

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/shared/composables/use-range-select.d.ts

@@ -0,0 +1,14 @@
+import { type MaybeRefOrGetter } from 'vue';
+interface RangeSelectEntry {
+    value: unknown;
+    selected: boolean;
+}
+interface UseRangeSelectOptions<TEntry extends RangeSelectEntry> {
+    entries: MaybeRefOrGetter<TEntry[]>;
+    onToggle: (value: TEntry['value']) => void;
+}
+export declare function useRangeSelect<TEntry extends RangeSelectEntry>(options: UseRangeSelectOptions<TEntry>): {
+    handleClick: (event: MouseEvent, entry: TEntry, index: number) => void;
+    reset: () => void;
+};
+export {};

package/dist/runtime/shared/composables/use-range-select.js

@@ -0,0 +1,27 @@
+import { ref, toValue } from "vue";
+export function useRangeSelect(options) {
+  const anchorIndex = ref(null);
+  const anchorAction = ref(null);
+  function handleClick(event, entry, index) {
+    const entries = toValue(options.entries);
+    if (event.shiftKey && anchorIndex.value !== null && anchorAction.value !== null) {
+      const start = Math.min(anchorIndex.value, index);
+      const end = Math.max(anchorIndex.value, index);
+      const shouldSelect = anchorAction.value === "select";
+      for (let i = start; i <= end; i++) {
+        const e = entries[i];
+        if (e && e.selected !== shouldSelect) options.onToggle(e.value);
+      }
+      anchorIndex.value = index;
+    } else {
+      anchorAction.value = entry.selected ? "deselect" : "select";
+      anchorIndex.value = index;
+      options.onToggle(entry.value);
+    }
+  }
+  function reset() {
+    anchorIndex.value = null;
+    anchorAction.value = null;
+  }
+  return { handleClick, reset };
+}

package/dist/runtime/shared/composables/use-responsive-value.d.ts

@@ -0,0 +1,6 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { InferResponsiveValue, ResponsiveTransformResult, ResponsiveTransformKey, ResponsiveValueInput, ResponsiveTransformer } from '../types/responsive.js';
+export declare function getResponsiveValue<TValue extends ResponsiveValueInput>(value: TValue): InferResponsiveValue<TValue> | null;
+export declare function getResponsiveValue<TTransform extends ResponsiveTransformKey | ResponsiveTransformer<unknown>>(value: string, transform: TTransform): ResponsiveTransformResult<TTransform> | null;
+export declare function useResponsiveValue<TValue extends ResponsiveValueInput>(value: MaybeRefOrGetter<TValue>): ComputedRef<InferResponsiveValue<TValue> | null>;
+export declare function useResponsiveValue<TTransform extends ResponsiveTransformKey | ResponsiveTransformer<unknown>>(value: MaybeRefOrGetter<string>, transform: TTransform): ComputedRef<ResponsiveTransformResult<TTransform> | null>;

package/dist/runtime/shared/composables/use-responsive-value.js

@@ -0,0 +1,42 @@
+import { useNuxtApp } from "nuxt/app";
+import { computed, toValue } from "vue";
+import {
+  getOrderedBreakpointKeys,
+  resolveResponsiveValueAtBreakpoint
+} from "../utils/responsive.js";
+export function getResponsiveValue(value, transform) {
+  const resolvedValue = unwrapResponsiveValue(value);
+  const viewport = useCurrentViewport();
+  const context = {
+    breakpoint: viewport.breakpoint.value,
+    breakpointKeys: getOrderedBreakpointKeys(viewport)
+  };
+  if (typeof resolvedValue !== "string")
+    return resolveResponsiveValueAtBreakpoint(resolvedValue, context);
+  if (transform === void 0) return resolveResponsiveValueAtBreakpoint(resolvedValue, context);
+  return resolveResponsiveValueAtBreakpoint(resolvedValue, context, transform);
+}
+export function useResponsiveValue(value, transform) {
+  return computed(() => {
+    const resolvedValue = unwrapResponsiveValue(toValue(value));
+    if (typeof resolvedValue !== "string") return getResponsiveValue(resolvedValue);
+    if (transform === void 0) return getResponsiveValue(resolvedValue);
+    return getResponsiveValue(resolvedValue, transform);
+  });
+}
+function unwrapResponsiveValue(value) {
+  let currentValue = value;
+  while (typeof currentValue === "function") {
+    currentValue = currentValue();
+  }
+  return currentValue;
+}
+function useCurrentViewport() {
+  const nuxtApp = useNuxtApp();
+  if (!hasViewport(nuxtApp))
+    throw new Error("nuxt-viewport is required to resolve responsive values");
+  return nuxtApp.$viewport;
+}
+function hasViewport(value) {
+  return typeof value === "object" && value !== null && "$viewport" in value;
+}

package/dist/runtime/shared/index.d.ts

@@ -0,0 +1,10 @@
+export * from './composables/use-responsive-value.js';
+export * from './composables/use-range-select.js';
+export * from './types/responsive.js';
+export * from './types/utils.js';
+export * from './utils/object.js';
+export * from './utils/path.js';
+export * from './utils/predicate.js';
+export * from './utils/responsive.js';
+export * from './utils/registry.js';
+export * from './utils/render.js';

package/dist/runtime/shared/index.js

@@ -0,0 +1,10 @@
+export * from "./composables/use-responsive-value.js";
+export * from "./composables/use-range-select.js";
+export * from "./types/responsive.js";
+export * from "./types/utils.js";
+export * from "./utils/object.js";
+export * from "./utils/path.js";
+export * from "./utils/predicate.js";
+export * from "./utils/responsive.js";
+export * from "./utils/registry.js";
+export * from "./utils/render.js";

package/dist/runtime/shared/types/responsive.d.ts

@@ -0,0 +1,12 @@
+import type { SplitLitteral } from './utils.js';
+export type ResponsiveValueInput = string | number | boolean | (() => ResponsiveValueInput);
+export type ResponsiveTransformKey = 'string' | 'boolean' | 'integer' | 'float' | 'grid-cols' | 'grid-rows' | 'col' | 'row' | 'maxWidth' | 'maxHeight';
+export type ResponsiveTransformer<TOutput> = (value: string) => TOutput;
+export interface ResponsiveBreakpointContext {
+    breakpoint: string;
+    breakpointKeys: string[];
+}
+type ExtractResponsiveToken<TValue extends string> = TValue extends `${string}:${infer Output}` ? Output : TValue;
+export type InferResponsiveValue<TValue extends ResponsiveValueInput> = TValue extends string ? ExtractResponsiveToken<SplitLitteral<TValue, ' '>[number]> : TValue;
+export type ResponsiveTransformResult<TTransform> = TTransform extends ResponsiveTransformer<infer TOutput> ? TOutput : TTransform extends 'boolean' ? boolean : TTransform extends 'integer' | 'float' ? number : string;
+export {};

package/dist/runtime/shared/types/utils.d.ts

@@ -0,0 +1,75 @@
+import type { VNodeChild } from 'vue';
+export type Not<T, R> = T extends R ? never : R;
+export type Primitive = string | number | symbol;
+export type GenericObject = Record<Primitive, unknown>;
+export type BuildTuple<L extends number, T extends any[] = []> = T['length'] extends L ? T : BuildTuple<L, [...T, any]>;
+export type DecrementDepth<N extends number> = BuildTuple<N> extends [any, ...infer Rest] ? Rest['length'] : 0;
+export type MaybePromise<T> = T | Promise<T>;
+export type NestedPaths<T, MaxDepth extends number = 10> = [MaxDepth] extends [0] ? never : T extends Array<infer U> ? `${NestedPaths<U, DecrementDepth<MaxDepth>>}` : T extends object ? {
+    [K in keyof T & (string | number)]: K extends string ? `${K}` | `${K}.${NestedPaths<T[K], DecrementDepth<MaxDepth>>}` : never;
+}[keyof T & (string | number)] : never;
+export type NestedPathsForType<T, P, MaxDepth extends number = 8> = [MaxDepth] extends [0] ? never : T extends object ? T extends Array<any> ? never : {
+    [K in keyof T & (string | number)]: T[K] extends infer V ? V extends Array<any> ? V extends P ? `${K}` : never : V extends P ? `${K}` | `${K}.${NestedPathsForType<V, P, DecrementDepth<MaxDepth>>}` : V extends object ? `${K}.${NestedPathsForType<V, P, DecrementDepth<MaxDepth>>}` : never : never;
+}[keyof T & (string | number)] : never;
+export type NonNullableDeep<T> = T extends null | undefined ? never : T;
+export type NonEmptyArray<T> = [T, ...T[]];
+export type DeepRequired<T> = {
+    [P in keyof T]-?: DeepRequired<NonNullableDeep<T[P]>>;
+};
+export type RemoveNeverProps<T> = {
+    [K in keyof T as T[K] extends never | undefined ? never : K]: T[K];
+};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type Narrowable = string | number | boolean | symbol | object | undefined | null;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type RenderFunction<T extends any[]> = (...args: T) => VNodeChild;
+export type IsObject<T> = T extends object ? (T extends any[] ? never : T) : never;
+export type RenderableType = string | number | VNodeChild | null | undefined;
+export type LazyTextValue = string | number | (() => string | number);
+export type LazyRenderableValue = LazyTextValue | VNodeChild | (() => VNodeChild);
+export type InferParams<T> = T extends (params: infer P) => any ? P : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type DeepPrettify<T> = T extends Array<infer U> ? Array<DeepPrettify<U>> : T extends object ? {
+    [K in keyof T]: DeepPrettify<T[K]>;
+} & {} : T;
+export type PathToObject<Path extends string, Output> = Path extends `${infer First}.${infer Rest}` ? {
+    [K in First]: PathToObject<Rest, Output>;
+} : {
+    [K in Path]: Output;
+};
+export type RemoveDotKeys<T> = T extends Array<infer U> ? Array<RemoveDotKeys<U>> : {
+    [K in keyof T as K extends `${string}.${string}` ? never : K]: T[K] extends object ? RemoveDotKeys<T[K]> : T[K];
+};
+export type DeepTransformNestedPaths<T> = T extends unknown ? DeepTransformNestedPathsMember<T> : never;
+type DeepTransformNestedPathsMember<T> = DeepPrettify<RemoveDotKeys<{
+    [K in keyof T]: T[K] extends Array<infer U> ? Array<DeepTransformNestedPaths<U>> : T[K] extends object ? DeepTransformNestedPaths<T[K]> : T[K];
+} & UnionToIntersection<{
+    [K in Extract<keyof T, string>]: PathToObject<K, T[K] extends Array<infer U> ? U extends object ? Array<DeepTransformNestedPaths<U>> : T[K] : T[K] extends object ? DeepTransformNestedPaths<T[K]> : T[K]>;
+}[Extract<keyof T, string>]>>>;
+export type SplitLitteral<String extends string, Divider extends string> = string extends String ? string[] : String extends '' ? [] : String extends `${infer T}${Divider}${infer U}` ? [T, ...SplitLitteral<U, Divider>] : [String];
+export type HasParameters<T> = T extends (...args: []) => any ? false : true;
+export type DeepOmit<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? T[First] extends (infer U)[] ? Omit<T, First> & {
+    [P in First]: DeepOmit<U, Rest>[];
+} : Omit<T, First> & {
+    [P in First]: DeepOmit<T[First], Rest>;
+} : T : Omit<T, K>;
+export type DeepPick<T, K extends string> = UnionToIntersection<K extends K ? K extends `${infer First}.${infer Rest}` ? First extends keyof T ? T[First] extends (infer U)[] ? {
+    [P in First]: DeepPick<U, Rest>[];
+} : {
+    [P in First]: DeepPick<T[First], Rest>;
+} : never : Pick<T, K & keyof T> : never>;
+export type TypeFromPath<T extends GenericObject, Path extends string> = {
+    [K in Path]: K extends keyof T ? T[K] : K extends `${infer P}.${infer S}` ? T[P] extends GenericObject ? TypeFromPath<T[P], S> : never : never;
+}[Path];
+export type DeepTransform<T, FromType, ToType> = T extends FromType ? ToType : T extends Array<infer U> ? Array<DeepTransform<U, FromType, ToType>> : T extends (...args: any[]) => any ? T : T extends object ? {
+    [K in keyof T]: DeepTransform<T[K], FromType, ToType>;
+} : T;
+export type DeepRemoveIndexSignature<T> = T extends object ? T extends Array<infer U> ? Array<DeepRemoveIndexSignature<U>> : {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: DeepRemoveIndexSignature<T[K]>;
+} : T;
+export type PartialPick<T, K extends keyof T> = Partial<Pick<T, K>>;
+export {};

package/dist/runtime/shared/utils/object.d.ts

@@ -0,0 +1,4 @@
+import type { DeepOmit, DeepPick, NestedPaths, Prettify } from '../types/utils.js';
+export declare function omit<T extends Record<PropertyKey, any>, K extends NestedPaths<T>>(obj: T, keys: K[]): Prettify<DeepOmit<T, K>>;
+export declare function pick<T extends Record<PropertyKey, any>, K extends NestedPaths<T>>(obj: T, keys: K[]): Prettify<DeepPick<T, K>>;
+export declare function getObjectProperty(source: unknown, path: string): unknown;