@nu-grid/nuxt 0.1.1

package/dist/runtime/composables/_internal/useNuGridWheelSmoothing.js

@@ -0,0 +1,157 @@
+import { onUnmounted, watch } from "vue";
+export function useNuGridWheelSmoothing(containerRef, options = {}) {
+  const {
+    threshold = 100,
+    maxVelocityPxPerSec = 1e4,
+    maxVelocityPxPerSecTouchpad,
+    touchpadDeltaThreshold = 20,
+    stopOnInactivityMs = 70,
+    smoothingFactor = 0.35,
+    minStepPx = 1,
+    adaptive = true
+  } = options;
+  let pendingX = 0;
+  let pendingY = 0;
+  let rafId = null;
+  let lastFlushTime = null;
+  let inactivityTimer = null;
+  let velocityEwma = 0;
+  let isTouchpad = false;
+  const clampByVelocity = (delta, allowed) => {
+    if (allowed <= 0) return 0;
+    const absDelta = Math.abs(delta);
+    if (absDelta <= allowed) return delta;
+    return Math.sign(delta) * allowed;
+  };
+  const flushScroll = () => {
+    rafId = null;
+    const now = performance.now();
+    const dtMs = lastFlushTime ? now - lastFlushTime : 16;
+    lastFlushTime = now;
+    const dtSec = dtMs / 1e3;
+    const currentVelocity = dtSec > 0 ? Math.max(Math.abs(pendingX), Math.abs(pendingY)) / dtSec : 0;
+    velocityEwma = adaptive ? 0.2 * currentVelocity + 0.8 * velocityEwma : velocityEwma;
+    const resolveAdaptive = () => {
+      const effectiveMaxVelocity = isTouchpad && maxVelocityPxPerSecTouchpad !== void 0 ? maxVelocityPxPerSecTouchpad : maxVelocityPxPerSec;
+      if (!adaptive) {
+        return {
+          smoothing: smoothingFactor,
+          minStep: minStepPx,
+          velocityCap: effectiveMaxVelocity
+        };
+      }
+      if (velocityEwma < 800) {
+        return {
+          smoothing: 0.55,
+          minStep: 0.5,
+          velocityCap: effectiveMaxVelocity
+        };
+      }
+      if (velocityEwma < 2200) {
+        return {
+          smoothing: 0.4,
+          minStep: 1,
+          velocityCap: effectiveMaxVelocity
+        };
+      }
+      if (velocityEwma < 8e3) {
+        return {
+          smoothing: 0.32,
+          minStep: 1.5,
+          velocityCap: effectiveMaxVelocity * 0.85
+        };
+      }
+      return {
+        smoothing: 0.45,
+        minStep: 1.5,
+        velocityCap: effectiveMaxVelocity
+      };
+    };
+    const adaptiveParams = resolveAdaptive();
+    const allowedDelta = adaptiveParams.velocityCap * dtSec;
+    const el = containerRef.value;
+    if (!el) {
+      pendingX = 0;
+      pendingY = 0;
+      return;
+    }
+    const applyX = clampByVelocity(pendingX, allowedDelta);
+    const applyY = clampByVelocity(pendingY, allowedDelta);
+    const applyWithSmoothing = (pending, apply) => {
+      if (apply === 0 || pending === 0) return 0;
+      const softened = pending * adaptiveParams.smoothing;
+      const signedMin = Math.sign(pending) * adaptiveParams.minStep;
+      const target = Math.abs(softened) < Math.abs(signedMin) ? signedMin : softened;
+      return Math.abs(target) > Math.abs(apply) ? apply : target;
+    };
+    const finalX = applyWithSmoothing(pendingX, applyX);
+    const finalY = applyWithSmoothing(pendingY, applyY);
+    if (finalX !== 0 || finalY !== 0) {
+      el.scrollBy({ left: finalX, top: finalY });
+      pendingX -= finalX;
+      pendingY -= finalY;
+    }
+    if ((pendingX !== 0 || pendingY !== 0) && rafId === null) {
+      rafId = requestAnimationFrame(flushScroll);
+    }
+  };
+  const resetInactivityTimer = () => {
+    if (inactivityTimer) {
+      clearTimeout(inactivityTimer);
+    }
+    inactivityTimer = setTimeout(() => {
+      pendingX = 0;
+      pendingY = 0;
+      lastFlushTime = null;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+    }, stopOnInactivityMs);
+  };
+  const scheduleFlush = () => {
+    if (rafId === null) {
+      rafId = requestAnimationFrame(flushScroll);
+    }
+  };
+  const handleWheel = (event) => {
+    const el = containerRef.value;
+    if (!el) return;
+    if (event.deltaMode !== 0) return;
+    const magnitude = Math.max(Math.abs(event.deltaY), Math.abs(event.deltaX));
+    if (magnitude < threshold) return;
+    isTouchpad = maxVelocityPxPerSecTouchpad !== void 0 && magnitude < touchpadDeltaThreshold;
+    event.preventDefault();
+    pendingY += event.deltaY;
+    pendingX += event.deltaX;
+    scheduleFlush();
+    resetInactivityTimer();
+  };
+  const addListener = (el) => {
+    if (!el) return;
+    el.addEventListener("wheel", handleWheel, { passive: false });
+  };
+  const removeListener = (el) => {
+    if (!el) return;
+    el.removeEventListener("wheel", handleWheel);
+  };
+  watch(
+    () => containerRef.value,
+    (el, prev) => {
+      if (prev && prev !== el) removeListener(prev);
+      addListener(el);
+    },
+    { immediate: true }
+  );
+  onUnmounted(() => {
+    removeListener(containerRef.value);
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    if (inactivityTimer) {
+      clearTimeout(inactivityTimer);
+      inactivityTimer = null;
+    }
+  });
+}

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

@@ -0,0 +1,3 @@
+export type { NuGridStateSnapshot } from './_internal/useNuGridStatePersistence.js';
+export * from './useNuGridCellEditor.js';
+export * from './useNuGridCellTypeRegistry.js';

package/dist/runtime/composables/index.js

@@ -0,0 +1,2 @@
+export * from "./useNuGridCellEditor.js";
+export * from "./useNuGridCellTypeRegistry.js";

package/dist/runtime/composables/useNuGridCellEditor.d.ts

@@ -0,0 +1,91 @@
+import type { Ref } from 'vue';
+import type { NuGridCellEditorEmits, NuGridCellEditorProps } from '../types/index.js';
+/**
+ * Shared composable for building custom NuGrid cell editors
+ *
+ * This composable provides:
+ * - Keyboard event handling (Enter, Escape, Arrow keys, Tab)
+ * - Focus management (with scroll settling)
+ * - Blur handling (navigation-aware)
+ * - Manual focus trigger (for custom focus logic)
+ * - Custom focus callback support (for complex components)
+ *
+ * @example Basic usage
+ * ```vue
+ * <script setup>
+ * const props = defineProps<NuGridCellEditorProps>()
+ * const emit = defineEmits<NuGridCellEditorEmits>()
+ * const inputRef = ref(null)
+ *
+ * const { handleKeydown, handleBlur } = useNuGridCellEditor(props, emit, inputRef)
+ * </script>
+ *
+ * <template>
+ *   <USelect
+ *     ref="inputRef"
+ *     :model-value="modelValue"
+ *     @blur="handleBlur"
+ *     @keydown="handleKeydown"
+ *   />
+ * </template>
+ * ```
+ *
+ * @example Custom focus callback for complex components
+ * ```vue
+ * <script setup>
+ * const props = defineProps<NuGridCellEditorProps>()
+ * const emit = defineEmits<NuGridCellEditorEmits>()
+ * const editorRef = ref(null)
+ *
+ * // Custom focus logic for a complex editor component
+ * const customFocus = () => {
+ *   editorRef.value?.openDropdown()
+ *   editorRef.value?.selectAll()
+ * }
+ *
+ * const { handleKeydown, handleBlur } = useNuGridCellEditor(
+ *   props,
+ *   emit,
+ *   editorRef,
+ *   customFocus
+ * )
+ * </script>
+ * ```
+ *
+ * @example Manual focus control
+ * ```vue
+ * <script setup>
+ * const props = defineProps<NuGridCellEditorProps>()
+ * const emit = defineEmits<NuGridCellEditorEmits>()
+ * const inputRef = ref(null)
+ *
+ * const { handleKeydown, handleBlur, focusInput } = useNuGridCellEditor(props, emit, inputRef)
+ *
+ * // Manually trigger focus after some async operation
+ * async function loadDataAndFocus() {
+ *   await fetchData()
+ *   focusInput()
+ * }
+ * </script>
+ * ```
+ */
+export declare function useNuGridCellEditor(props: NuGridCellEditorProps, emit: NuGridCellEditorEmits, inputRef: Ref<any>, customFocusCallback?: () => void): {
+    /**
+     * Handle keyboard events for navigation and editing control
+     */
+    handleKeydown: (e: KeyboardEvent) => void;
+    /**
+     * Handle blur events (navigation-aware)
+     */
+    handleBlur: () => void;
+    /**
+     * Manually trigger focus on the input element
+     * Useful for custom focus logic or after async operations
+     */
+    focusInput: () => void;
+    /**
+     * Schedule navigation to another cell
+     * Emits stop-editing with direction, which is throttled by the scroll processing lock
+     */
+    scheduleNavigation: (direction: "up" | "down" | "next" | "previous") => void;
+};

package/dist/runtime/composables/useNuGridCellEditor.js

@@ -0,0 +1,82 @@
+import { nextTick, onMounted, watch } from "vue";
+export function useNuGridCellEditor(props, emit, inputRef, customFocusCallback) {
+  function scheduleNavigation(direction) {
+    emit("update:isNavigating", true);
+    emit("stop-editing", direction);
+  }
+  function focusInput() {
+    nextTick(() => {
+      if (customFocusCallback) {
+        customFocusCallback();
+        return;
+      }
+      if (inputRef.value?.inputRef) {
+        inputRef.value.inputRef.focus({ preventScroll: true });
+      } else if (inputRef.value?.focus) {
+        inputRef.value.focus({ preventScroll: true });
+      }
+    });
+  }
+  watch(
+    () => props.shouldFocus,
+    (shouldFocus) => {
+      if (shouldFocus) {
+        focusInput();
+      }
+    },
+    { immediate: true }
+  );
+  onMounted(() => {
+    if (props.shouldFocus) {
+      focusInput();
+    }
+  });
+  function handleBlur() {
+    if (!props.isNavigating) {
+      emit("stop-editing");
+    }
+  }
+  function handleKeydown(e) {
+    e.stopPropagation();
+    if (e.key === "Enter") {
+      e.preventDefault();
+      emit("stop-editing");
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      emit("cancel-editing");
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      if (e.metaKey || e.ctrlKey) return;
+      scheduleNavigation("up");
+    } else if (e.key === "ArrowDown") {
+      e.preventDefault();
+      if (e.metaKey || e.ctrlKey) return;
+      scheduleNavigation("down");
+    } else if (e.key === "Tab") {
+      e.preventDefault();
+      scheduleNavigation(e.shiftKey ? "previous" : "next");
+    } else if (e.key === "PageUp" || e.key === "PageDown") {
+      e.preventDefault();
+    }
+  }
+  return {
+    /**
+     * Handle keyboard events for navigation and editing control
+     */
+    handleKeydown,
+    /**
+     * Handle blur events (navigation-aware)
+     */
+    handleBlur,
+    /**
+     * Manually trigger focus on the input element
+     * Useful for custom focus logic or after async operations
+     */
+    focusInput,
+    /**
+     * Schedule navigation to another cell
+     * Emits stop-editing with direction, which is throttled by the scroll processing lock
+     */
+    scheduleNavigation
+  };
+}

package/dist/runtime/composables/useNuGridCellTypeRegistry.d.ts

@@ -0,0 +1,85 @@
+import type { TableData } from '@nuxt/ui';
+import type { Ref } from 'vue';
+import type { NuGridCellType } from '../types/cells.js';
+/**
+ * Cell type registry for managing cell types
+ * Provides centralized registration, lookup, and merging of cell types
+ */
+export declare class NuGridCellTypeRegistry {
+    private cellTypes;
+    private builtInTypes;
+    private typeCache;
+    private editorCache;
+    private rendererCache;
+    constructor();
+    /**
+     * Register a cell type
+     * If a cell type with the same name already exists, it will be replaced
+     */
+    register(cellType: NuGridCellType): void;
+    /**
+     * Register multiple cell types at once
+     */
+    registerAll(cellTypes: NuGridCellType[]): void;
+    /**
+     * Get a cell type by name
+     * Returns undefined if not found
+     * Uses cache for performance
+     */
+    get(name: string): NuGridCellType | undefined;
+    /**
+     * Get editor for a cell type (cached)
+     */
+    getEditor(name: string): NuGridCellType['editor'];
+    /**
+     * Get renderer for a cell type (cached)
+     */
+    getRenderer(name: string): NuGridCellType['renderer'];
+    /**
+     * Check if a cell type is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered cell types
+     */
+    getAll(): NuGridCellType[];
+    /**
+     * Set built-in cell types
+     * These are merged with custom cell types, with custom types taking precedence
+     */
+    setBuiltInTypes(cellTypes: NuGridCellType[]): void;
+    /**
+     * Merge custom cell types with built-in types
+     * Custom types override built-in types with the same name
+     * New custom types are added
+     */
+    mergeCellTypes(customTypes?: NuGridCellType[]): NuGridCellType[];
+}
+/**
+ * Global cell type registry instance
+ */
+declare const globalRegistry: NuGridCellTypeRegistry;
+/**
+ * Composable for accessing the cell type registry
+ * Provides reactive access to cell types
+ * Optimized for performance with caching
+ */
+export declare function useNuGridCellTypeRegistry<T extends TableData = TableData>(customTypes?: Ref<NuGridCellType<T>[] | undefined>): {
+    registry: NuGridCellTypeRegistry;
+    cellTypes: import("vue").ComputedRef<NuGridCellType<T>[]>;
+    getCellType: (name: string) => NuGridCellType<T> | undefined;
+    getDefaultEditor: (cellDataType: string) => NuGridCellType["editor"];
+    getRenderer: (cellDataType: string) => NuGridCellType["renderer"];
+    getFilter: (cellDataType: string) => NuGridCellType["filter"];
+    getFilterFn: (cellDataType: string) => NuGridCellType<T>["filterFn"];
+    getKeyboardHandler: (cellDataType: string) => NuGridCellType<T>["keyboardHandler"];
+    getValidation: (cellDataType: string) => NuGridCellType<T>["validation"];
+    getFormatter: (cellDataType: string) => NuGridCellType<T>["formatter"];
+    getColumnMenuItems: (cellDataType: string) => NuGridCellType<T>["columnMenuItems"];
+    getDefaultCellRenderer: (cellDataType: string) => NuGridCellType<T>["defaultCellRenderer"];
+    isFilteringEnabled: (cellDataType: string) => boolean;
+};
+/**
+ * Export the global registry for direct access if needed
+ */
+export { globalRegistry as nuGridCellTypeRegistry };

package/dist/runtime/composables/useNuGridCellTypeRegistry.js

@@ -0,0 +1,202 @@
+import { computed } from "vue";
+import { builtInCellTypes } from "../cell-types/index.js";
+export class NuGridCellTypeRegistry {
+  cellTypes = /* @__PURE__ */ new Map();
+  builtInTypes = [];
+  // Cache for cell type lookups to improve performance
+  typeCache = /* @__PURE__ */ new Map();
+  // Cache for cell type properties to avoid repeated lookups
+  editorCache = /* @__PURE__ */ new Map();
+  rendererCache = /* @__PURE__ */ new Map();
+  constructor() {
+    if (builtInCellTypes && Array.isArray(builtInCellTypes)) {
+      this.setBuiltInTypes(builtInCellTypes);
+    } else {
+      console.warn(
+        "[NuGrid] builtInCellTypes is not available or not an array. Cell types may not be registered."
+      );
+    }
+  }
+  /**
+   * Register a cell type
+   * If a cell type with the same name already exists, it will be replaced
+   */
+  register(cellType) {
+    this.cellTypes.set(cellType.name, cellType);
+    this.typeCache.delete(cellType.name);
+    this.editorCache.delete(cellType.name);
+    this.rendererCache.delete(cellType.name);
+  }
+  /**
+   * Register multiple cell types at once
+   */
+  registerAll(cellTypes) {
+    for (const cellType of cellTypes) {
+      this.register(cellType);
+    }
+  }
+  /**
+   * Get a cell type by name
+   * Returns undefined if not found
+   * Uses cache for performance
+   */
+  get(name) {
+    if (this.typeCache.has(name)) {
+      return this.typeCache.get(name);
+    }
+    const cellType = this.cellTypes.get(name);
+    this.typeCache.set(name, cellType);
+    return cellType;
+  }
+  /**
+   * Get editor for a cell type (cached)
+   */
+  getEditor(name) {
+    if (this.editorCache.has(name)) {
+      return this.editorCache.get(name);
+    }
+    const cellType = this.get(name);
+    const editor = cellType?.editor;
+    this.editorCache.set(name, editor);
+    return editor;
+  }
+  /**
+   * Get renderer for a cell type (cached)
+   */
+  getRenderer(name) {
+    if (this.rendererCache.has(name)) {
+      return this.rendererCache.get(name);
+    }
+    const cellType = this.get(name);
+    const renderer = cellType?.renderer;
+    this.rendererCache.set(name, renderer);
+    return renderer;
+  }
+  /**
+   * Check if a cell type is registered
+   */
+  has(name) {
+    return this.cellTypes.has(name);
+  }
+  /**
+   * Get all registered cell types
+   */
+  getAll() {
+    return Array.from(this.cellTypes.values());
+  }
+  /**
+   * Set built-in cell types
+   * These are merged with custom cell types, with custom types taking precedence
+   */
+  setBuiltInTypes(cellTypes) {
+    if (!Array.isArray(cellTypes)) {
+      console.warn("setBuiltInTypes: cellTypes must be an array");
+      return;
+    }
+    this.builtInTypes = cellTypes;
+    for (const cellType of cellTypes) {
+      if (!this.cellTypes.has(cellType.name)) {
+        this.register(cellType);
+      }
+    }
+  }
+  /**
+   * Merge custom cell types with built-in types
+   * Custom types override built-in types with the same name
+   * New custom types are added
+   */
+  mergeCellTypes(customTypes) {
+    if (!customTypes || customTypes.length === 0) {
+      return this.builtInTypes;
+    }
+    const customTypeMap = new Map(customTypes.map((t) => [t.name, t]));
+    const mergedTypes = this.builtInTypes.map(
+      (builtIn) => customTypeMap.get(builtIn.name) || builtIn
+    );
+    for (const custom of customTypes) {
+      if (!this.builtInTypes.some((b) => b.name === custom.name)) {
+        mergedTypes.push(custom);
+      }
+    }
+    return mergedTypes;
+  }
+}
+const globalRegistry = new NuGridCellTypeRegistry();
+export function useNuGridCellTypeRegistry(customTypes) {
+  const registry = globalRegistry;
+  const customTypeMap = computed(() => {
+    if (!customTypes?.value) return null;
+    return new Map(customTypes.value.map((t) => [t.name, t]));
+  });
+  const cellTypes = computed(() => {
+    if (customTypes?.value) {
+      return registry.mergeCellTypes(customTypes.value);
+    }
+    return registry.getAll();
+  });
+  const getCellType = (name) => {
+    const customMap = customTypeMap.value;
+    if (customMap) {
+      const custom = customMap.get(name);
+      if (custom) return custom;
+    }
+    return registry.get(name);
+  };
+  const getDefaultEditor = (cellDataType) => {
+    return registry.getEditor(cellDataType);
+  };
+  const getRenderer = (cellDataType) => {
+    return registry.getRenderer(cellDataType);
+  };
+  const getFilter = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.filter;
+  };
+  const getFilterFn = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.filterFn;
+  };
+  const getKeyboardHandler = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.keyboardHandler;
+  };
+  const getValidation = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.validation;
+  };
+  const getFormatter = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.formatter;
+  };
+  const getColumnMenuItems = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.columnMenuItems;
+  };
+  const getDefaultCellRenderer = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    return cellType?.defaultCellRenderer;
+  };
+  const isFilteringEnabled = (cellDataType) => {
+    const cellType = getCellType(cellDataType);
+    if (cellType?.enableFiltering !== void 0) {
+      return cellType.enableFiltering;
+    }
+    return !!cellType?.filter;
+  };
+  return {
+    registry,
+    cellTypes,
+    getCellType,
+    getDefaultEditor,
+    getRenderer,
+    getFilter,
+    getFilterFn,
+    getKeyboardHandler,
+    getValidation,
+    getFormatter,
+    getColumnMenuItems,
+    getDefaultCellRenderer,
+    isFilteringEnabled
+  };
+}
+export { globalRegistry as nuGridCellTypeRegistry };

package/dist/runtime/config/_internal/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */
+export { nuGridDefaults } from './options-defaults.js';
+export { getDefaults, usePropsWithDefaults, usePropWithDefault } from './prop-utils.js';

package/dist/runtime/config/_internal/index.js

@@ -0,0 +1,2 @@
+export { nuGridDefaults } from "./options-defaults.js";
+export { getDefaults, usePropsWithDefaults, usePropWithDefault } from "./prop-utils.js";