nuxt-ui-tools 0.1.3 → 1.0.0

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

@@ -21,11 +21,11 @@ export interface QueryStateClientOptions {
     /** History mode used when callers do not provide one for a write. */
     defaultHistoryMode?: HistoryMode;
 }
-type PendingUpdate = {
+interface PendingUpdate {
     key: string;
     value: string | null;
     historyMode: HistoryMode;
-};
+}
 type Subscriber = (key: string, value: string | null) => void;
 export declare class QueryStateClient {
     private router;
@@ -45,10 +45,10 @@ export declare class QueryStateClient {
     /** Queue a single param update. Flushed at the end of the microtask. */
     set(key: string, value: string | null, historyMode?: HistoryMode): void;
     /** Queue multiple param updates as a single batch. */
-    setBatch(updates: Array<{
+    setBatch(updates: {
         key: string;
         value: string | null;
-    }>, historyMode?: HistoryMode): void;
+    }[], historyMode?: HistoryMode): void;
     private scheduleFlush;
     private flush;
     subscribe(fn: Subscriber): () => void;
@@ -63,17 +63,17 @@ export declare class QueryStateClient {
         cache: {
             [k: string]: string | null;
         };
-        pendingUpdates: PendingUpdate[];
-        subscriberCount: number;
         mutationLog: {
             timestamp: number;
             key: string;
             value: string | null;
             historyMode: HistoryMode;
         }[];
+        pendingUpdates: PendingUpdate[];
         routeQuery: {
             [x: string]: import("vue-router").LocationQueryValue | import("vue-router").LocationQueryValue[];
         };
+        subscriberCount: number;
     };
 }
 export {};

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

@@ -1,3 +1,5 @@
+import { isString } from "#ui-tools/shared/utils/predicate";
+import { isNullish } from "../shared/utils/predicate.js";
 export class QueryStateClient {
   router;
   defaultHistoryMode;
@@ -29,8 +31,13 @@ export class QueryStateClient {
   /** Read directly from the current route query. */
   readFromRoute(key) {
     const value = this.router.currentRoute.value.query[key];
-    if (value == null) return null;
-    return Array.isArray(value) ? value[0] : value;
+    if (isNullish(value)) {
+      return null;
+    }
+    if (Array.isArray(value)) {
+      return value[0] ?? null;
+    }
+    return isString(value) ? value : null;
   }
   // ---------------------------------------------------------------------------
   // Write (batched)
@@ -39,8 +46,8 @@ export class QueryStateClient {
   set(key, value, historyMode) {
     this.cache.set(key, value);
     const mode = historyMode ?? this.defaultHistoryMode;
-    this.pendingUpdates.push({ key, value, historyMode: mode });
-    this._mutationLog.push({ timestamp: Date.now(), key, value, historyMode: mode });
+    this.pendingUpdates.push({ historyMode: mode, key, value });
+    this._mutationLog.push({ historyMode: mode, key, timestamp: Date.now(), value });
     this.scheduleFlush();
     for (const subscriber of this.subscribers) {
       subscriber(key, value);
@@ -53,12 +60,12 @@ export class QueryStateClient {
     const now = Date.now();
     for (const update of updates) {
       this.cache.set(update.key, update.value);
-      this.pendingUpdates.push({ key: update.key, value: update.value, historyMode: mode });
+      this.pendingUpdates.push({ historyMode: mode, key: update.key, value: update.value });
       this._mutationLog.push({
-        timestamp: now,
+        historyMode: mode,
         key: update.key,
-        value: update.value,
-        historyMode: mode
+        timestamp: now,
+        value: update.value
       });
     }
     this.scheduleFlush();
@@ -73,26 +80,32 @@ export class QueryStateClient {
   // Flush
   // ---------------------------------------------------------------------------
   scheduleFlush() {
-    if (this.flushScheduled) return;
+    if (this.flushScheduled) {
+      return;
+    }
     this.flushScheduled = true;
     queueMicrotask(() => this.flush());
   }
   flush() {
     this.flushScheduled = false;
-    if (!this.pendingUpdates.length) return;
+    if (!this.pendingUpdates.length) {
+      return;
+    }
     const updates = this.pendingUpdates;
     this.pendingUpdates = [];
     const usePush = updates.some((u) => u.historyMode === "push");
     const currentQuery = { ...this.router.currentRoute.value.query };
     const nextQuery = { ...currentQuery };
     for (const { key, value } of updates) {
-      if (value == null) {
+      if (isNullish(value)) {
         delete nextQuery[key];
       } else {
         nextQuery[key] = value;
       }
     }
-    if (queryEquals(currentQuery, nextQuery)) return;
+    if (queryEquals(currentQuery, nextQuery)) {
+      return;
+    }
     const navigate = usePush ? this.router.push.bind(this.router) : this.router.replace.bind(this.router);
     navigate({ query: nextQuery });
   }
@@ -109,10 +122,10 @@ export class QueryStateClient {
   // Sync from route — call this on route changes to invalidate stale cache
   // ---------------------------------------------------------------------------
   syncFromRoute() {
-    const query = this.router.currentRoute.value.query;
+    const { query } = this.router.currentRoute.value;
     for (const [key, cached] of this.cache) {
       const routeValue = query[key];
-      const rawRoute = routeValue == null ? null : Array.isArray(routeValue) ? routeValue[0] : routeValue;
+      const rawRoute = isNullish(routeValue) ? null : Array.isArray(routeValue) ? routeValue[0] ?? null : isString(routeValue) ? routeValue : null;
       if (rawRoute !== cached) {
         this.cache.set(key, rawRoute);
         for (const subscriber of this.subscribers) {
@@ -140,26 +153,32 @@ export class QueryStateClient {
     };
   }
   notifyDevtools() {
-    for (const fn of this._devtoolsListeners) fn();
+    for (const fn of this._devtoolsListeners) {
+      fn();
+    }
   }
   /** Snapshot of all internal state for devtools inspection. */
   __devtools__() {
     return {
       cache: Object.fromEntries(this.cache),
-      pendingUpdates: [...this.pendingUpdates],
-      subscriberCount: this.subscribers.size,
       mutationLog: this._mutationLog.slice(-50),
       // keep last 50
-      routeQuery: { ...this.router.currentRoute.value.query }
+      pendingUpdates: [...this.pendingUpdates],
+      routeQuery: { ...this.router.currentRoute.value.query },
+      subscriberCount: this.subscribers.size
     };
   }
 }
 function queryEquals(a, b) {
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
   for (const key of aKeys) {
-    if (a[key] !== b[key]) return false;
+    if (a[key] !== b[key]) {
+      return false;
+    }
   }
   return true;
 }

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

@@ -1,3 +1,4 @@
+import { isNullish } from "../shared/utils/predicate.js";
 export const stringCodec = {
   parse: (raw) => raw,
   serialize: (value) => value
@@ -18,11 +19,14 @@ export function createEnumCodec(values) {
   const set = new Set(values);
   return {
     parse(raw) {
-      if (set.has(raw)) return raw;
-      return void 0;
+      if (set.has(raw)) {
+        return raw;
+      }
     },
     serialize(value) {
-      if (value != null && set.has(value)) return value;
+      if (!isNullish(value) && set.has(value)) {
+        return value;
+      }
       return null;
     }
   };
@@ -30,11 +34,15 @@ export function createEnumCodec(values) {
 export function createArrayCodec(itemCodec, separator = ",") {
   return {
     parse(raw) {
-      if (!raw) return [];
+      if (!raw) {
+        return [];
+      }
       return raw.split(separator).map((part) => itemCodec.parse(part));
     },
     serialize(value) {
-      if (!value.length) return null;
+      if (!value.length) {
+        return null;
+      }
       return value.map((item) => itemCodec.serialize(item)).filter(Boolean).join(separator);
     }
   };

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

@@ -8,8 +8,10 @@
  * 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 { WritableComputedRef } from 'vue';
+import type { Router } from 'vue-router';
+import { QueryStateClient } from './client.js';
+import type { HistoryMode } from './client.js';
 import type { QueryCodec } from './codecs.js';
 /**
  * Pre-register a query-state client for a router instance.
@@ -23,7 +25,7 @@ import type { QueryCodec } from './codecs.js';
  * registerQueryStateClient(router, client)
  * ```
  */
-export declare function registerQueryStateClient(router: object, client: QueryStateClient): void;
+export declare function registerQueryStateClient(router: Router, client: QueryStateClient): void;
 /**
  * Returns the shared query-state client for the current router.
  *
@@ -41,7 +43,7 @@ export declare function useQueryStateClient(options?: {
     defaultHistoryMode?: HistoryMode;
 }): QueryStateClient;
 type ResolveDefaultedValue<TValue, TDefault> = undefined extends TDefault ? TValue : Exclude<TValue, undefined>;
-type UseQueryStateBaseOptions<TValue> = {
+interface 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. */
@@ -50,7 +52,7 @@ type UseQueryStateBaseOptions<TValue> = {
     omitDefault?: boolean;
     /** Override the router history mode for writes from this state. */
     historyMode?: HistoryMode;
-};
+}
 /**
  * Options for a single typed query-state binding.
  *
@@ -84,10 +86,10 @@ export interface DynamicQueryStateOptions<TDefinition, TValue> {
      * 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<{
+    resolve: (definition: TDefinition) => {
         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;
     /**
@@ -101,7 +103,7 @@ export interface DynamicQueryStateOptions<TDefinition, TValue> {
 }
 export interface DynamicQueryStateDef<TValue> {
     [DYNAMIC_MARKER]: true;
-    _options: DynamicQueryStateOptions<any, TValue>;
+    options: DynamicQueryStateOptions<any, TValue>;
 }
 /**
  * Declares a dynamic grouped query-state field for use inside `useQueryStates(...)`.

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

@@ -1,5 +1,7 @@
 import { computed, onScopeDispose, shallowRef } from "vue";
 import { useRouter } from "vue-router";
+import { hasProperty, isObject } from "#ui-tools/shared/utils/predicate";
+import { isNullish } from "../shared/utils/predicate.js";
 import { QueryStateClient } from "./client.js";
 const clientRegistry = /* @__PURE__ */ new WeakMap();
 export function registerQueryStateClient(router, client) {
@@ -10,8 +12,8 @@ export function useQueryStateClient(options) {
   let client = clientRegistry.get(router);
   if (!client) {
     client = new QueryStateClient({
-      router,
-      defaultHistoryMode: options?.defaultHistoryMode
+      defaultHistoryMode: options?.defaultHistoryMode,
+      router
     });
     clientRegistry.set(router, client);
     router.afterEach(() => {
@@ -27,7 +29,9 @@ export function useQueryState(options) {
   const internal = shallowRef(readFromClient());
   function readFromClient() {
     const raw = client.get(key);
-    if (raw == null) return defaultValue;
+    if (isNullish(raw)) {
+      return defaultValue;
+    }
     const parsed = codec.parse(raw);
     return parsed === void 0 ? defaultValue : parsed;
   }
@@ -37,11 +41,15 @@ export function useQueryState(options) {
     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;
-    })();
+    if (changedKey !== key) {
+      return;
+    }
+    if (isNullish(rawValue)) {
+      internal.value = defaultValue;
+      return;
+    }
+    const parsed = codec.parse(rawValue);
+    internal.value = parsed === void 0 ? defaultValue : parsed;
   });
   onScopeDispose(unsubscribe);
   return computed({
@@ -56,11 +64,14 @@ const DYNAMIC_MARKER = Symbol("dynamicQueryState");
 export function dynamicQueryState(options) {
   return {
     [DYNAMIC_MARKER]: true,
-    _options: options
+    options
   };
 }
 function isDynamicDef(value) {
-  return value != null && typeof value === "object" && DYNAMIC_MARKER in value;
+  return isObject(value) && hasProperty(value, DYNAMIC_MARKER);
+}
+function resolveQueryStatesValues(values) {
+  return values;
 }
 export function useQueryStates(options) {
   const client = useQueryStateClient();
@@ -85,14 +96,18 @@ export function useQueryStates(options) {
     const def = schema[propKey];
     const urlKey = staticUrlKeys.get(propKey);
     const raw = client.get(urlKey);
-    if (raw == null) return def.defaultValue;
+    if (isNullish(raw)) {
+      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 dynDef = schema[propKey].options;
     const definitions = dynDef.definitions();
-    if (!definitions.length) return dynDef.defaultValue;
+    if (!definitions.length) {
+      return dynDef.defaultValue;
+    }
     const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
     const entries = /* @__PURE__ */ new Map();
     for (const def of definitions) {
@@ -100,16 +115,18 @@ export function useQueryStates(options) {
       for (const { urlKey, codec } of resolvedKeys) {
         const fullKey = `${fullPrefix}.${urlKey}`;
         const raw = client.get(fullKey);
-        if (raw != null && raw !== "") {
+        if (!isNullish(raw) && raw !== "") {
           entries.set(urlKey, codec.parse(raw));
         }
       }
     }
-    if (entries.size === 0) return dynDef.defaultValue;
+    if (entries.size === 0) {
+      return dynDef.defaultValue;
+    }
     return dynDef.parse(entries, definitions);
   }
   function writeDynamic(propKey, value) {
-    const dynDef = schema[propKey]._options;
+    const dynDef = schema[propKey].options;
     const definitions = dynDef.definitions();
     const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
     const updates = [];
@@ -131,13 +148,13 @@ export function useQueryStates(options) {
           break;
         }
       }
-      if (codec && val != null) {
+      if (codec && !isNullish(val)) {
         const existing = updates.findIndex((u) => u.key === fullKey);
         const serializedValue = codec.serialize(val);
-        if (existing >= 0) {
-          updates[existing].value = serializedValue;
-        } else {
+        if (existing === -1) {
           updates.push({ key: fullKey, value: serializedValue });
+        } else {
+          updates[existing].value = serializedValue;
         }
       }
     }
@@ -145,9 +162,13 @@ export function useQueryStates(options) {
   }
   function readAll() {
     const result = {};
-    for (const k of staticKeys) result[k] = readStatic(k);
-    for (const k of dynamicKeys) result[k] = readDynamic(k);
-    return result;
+    for (const k of staticKeys) {
+      result[k] = readStatic(k);
+    }
+    for (const k of dynamicKeys) {
+      result[k] = readDynamic(k);
+    }
+    return resolveQueryStatesValues(result);
   }
   function writeAll(values) {
     const updates = [];
@@ -172,9 +193,9 @@ export function useQueryStates(options) {
       return;
     }
     for (const k of dynamicKeys) {
-      const dynDef = schema[k]._options;
+      const dynDef = schema[k].options;
       const fullPrefix = prefix ? `${prefix}.${dynDef.urlPrefix}` : dynDef.urlPrefix;
-      if (changedKey.startsWith(fullPrefix + ".")) {
+      if (changedKey.startsWith(`${fullPrefix}.`)) {
         internal.value = readAll();
         return;
       }

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

@@ -1,4 +1,4 @@
-import { type MaybeRefOrGetter } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
 interface RangeSelectEntry {
     value: unknown;
     selected: boolean;

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

@@ -8,9 +8,11 @@ export function useRangeSelect(options) {
       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++) {
+      for (let i = start; i <= end; i += 1) {
         const e = entries[i];
-        if (e && e.selected !== shouldSelect) options.onToggle(e.value);
+        if (e && e.selected !== shouldSelect) {
+          options.onToggle(e.value);
+        }
       }
       anchorIndex.value = index;
     } else {

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

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

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

@@ -1,9 +1,7 @@
 import { useNuxtApp } from "nuxt/app";
 import { computed, toValue } from "vue";
-import {
-  getOrderedBreakpointKeys,
-  resolveResponsiveValueAtBreakpoint
-} from "../utils/responsive.js";
+import { isFunction, isObject, isString } from "../utils/predicate.js";
+import { getOrderedBreakpointKeys, resolveResponsiveValueAtBreakpoint } from "../utils/responsive.js";
 export function getResponsiveValue(value, transform) {
   const resolvedValue = unwrapResponsiveValue(value);
   const viewport = useCurrentViewport();
@@ -11,32 +9,43 @@ export function getResponsiveValue(value, transform) {
     breakpoint: viewport.breakpoint.value,
     breakpointKeys: getOrderedBreakpointKeys(viewport)
   };
-  if (typeof resolvedValue !== "string")
+  if (!isString(resolvedValue)) {
     return resolveResponsiveValueAtBreakpoint(resolvedValue, context);
-  if (transform === void 0) 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);
+    if (!isString(resolvedValue)) {
+      return getResponsiveValue(resolvedValue);
+    }
+    if (transform === void 0) {
+      return getResponsiveValue(resolvedValue);
+    }
     return getResponsiveValue(resolvedValue, transform);
   });
 }
 function unwrapResponsiveValue(value) {
   let currentValue = value;
-  while (typeof currentValue === "function") {
+  while (isResponsiveValueGetter(currentValue)) {
     currentValue = currentValue();
   }
   return currentValue;
 }
+function isResponsiveValueGetter(value) {
+  return isFunction(value);
+}
 function useCurrentViewport() {
   const nuxtApp = useNuxtApp();
-  if (!hasViewport(nuxtApp))
+  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;
+  return isObject(value) && "$viewport" in value;
 }

package/dist/runtime/shared/styles/scrollbars.css

@@ -0,0 +1 @@
+:root{--nut-scrollbar-size:11px;--nut-scrollbar-gap:3px;--nut-scrollbar-thumb:color-mix(in srgb,var(--ui-text,#1f1d1a) 18%,transparent);--nut-scrollbar-thumb-hover:color-mix(in srgb,var(--ui-text,#1f1d1a) 32%,transparent);--nut-scrollbar-thumb-active:color-mix(in srgb,var(--ui-text,#1f1d1a) 44%,transparent)}@supports not selector(::-webkit-scrollbar){*{scrollbar-color:transparent transparent;scrollbar-width:thin;transition:scrollbar-color .2s ease}:hover{scrollbar-color:var(--nut-scrollbar-thumb) transparent}}@supports selector(::-webkit-scrollbar){::-webkit-scrollbar{background:transparent;height:var(--nut-scrollbar-size);width:var(--nut-scrollbar-size)}::-webkit-scrollbar-corner,::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background-clip:padding-box;background-color:transparent;border:var(--nut-scrollbar-gap) solid transparent;border-radius:999px}:hover::-webkit-scrollbar-thumb{background-color:var(--nut-scrollbar-thumb)}::-webkit-scrollbar-thumb:hover{background-color:var(--nut-scrollbar-thumb-hover)}::-webkit-scrollbar-thumb:active{background-color:var(--nut-scrollbar-thumb-active)}}

package/dist/runtime/shared/styles/tokens.css

@@ -0,0 +1 @@
+:root{--nut-form-veil:rgba(31,29,26,.18)}.dark{--nut-form-veil:rgba(0,0,0,.45)}

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

@@ -1,15 +1,18 @@
 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>;
+type GenericValue = never extends never ? unknown : never;
+export type GenericObject = {
+    [K in Primitive]: GenericValue;
+};
 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 ? {
+export type NestedPaths<T, MaxDepth extends number = 10> = [MaxDepth] extends [0] ? never : T extends (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;
+export type NestedPathsForType<T, P, MaxDepth extends number = 8> = [MaxDepth] extends [0] ? never : T extends object ? T extends any[] ? never : {
+    [K in keyof T & (string | number)]: T[K] extends infer V ? V extends 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[]];
@@ -32,23 +35,23 @@ 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 ? {
+} & NonNullable<unknown>;
+export type DeepPrettify<T> = T extends (infer U)[] ? DeepPrettify<U>[] : T extends object ? {
     [K in keyof T]: DeepPrettify<T[K]>;
-} & {} : T;
+} & NonNullable<unknown> : 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>> : {
+export type RemoveDotKeys<T> = T extends (infer U)[] ? 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];
+    [K in keyof T]: T[K] extends (infer U)[] ? 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]>;
+    [K in Extract<keyof T, string>]: PathToObject<K, T[K] extends (infer U)[] ? U extends object ? 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;
@@ -65,10 +68,10 @@ export type DeepPick<T, K extends string> = UnionToIntersection<K extends K ? K
 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 ? {
+export type DeepTransform<T, FromType, ToType> = T extends FromType ? ToType : T extends (infer U)[] ? 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>> : {
+export type DeepRemoveIndexSignature<T> = T extends object ? T extends (infer U)[] ? 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>>;

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

@@ -1,4 +1,6 @@
-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;
+import type { DeepOmit, DeepPick, GenericObject, NestedPaths, Prettify } from '../types/utils.js';
+export declare function omit<T extends GenericObject, K extends NestedPaths<T>>(obj: T, keys: K[]): Prettify<DeepOmit<T, K>>;
+export declare function pick<T extends GenericObject, K extends NestedPaths<T>>(obj: T, keys: K[]): Prettify<DeepPick<T, K>>;
+type ObjectPropertyValue = GenericObject[string];
+export declare function getObjectProperty<T>(source: T, path: string): ObjectPropertyValue | undefined;
+export {};