@nu-grid/nuxt 0.1.1

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

@@ -0,0 +1,137 @@
+import { computed, h, ref, watch } from "vue";
+import { nuGridCellTypeRegistry } from "../useNuGridCellTypeRegistry.js";
+const defaultButton = {
+  icon: "i-lucide-ellipsis-vertical",
+  color: "neutral",
+  variant: "ghost",
+  class: "ml-auto"
+};
+function createActionMenuColumn(options, enabledRef, menuOpenStates) {
+  const requiredMeta = {
+    actionMenuEnabled: true,
+    enabledRef,
+    getActions: options.getActions,
+    isRowEnabledFn: options.isRowEnabled,
+    button: {
+      ...defaultButton,
+      ...options.button
+    },
+    menuOpenStates
+  };
+  const defaultColumn = {
+    id: "__actions",
+    size: 60,
+    minSize: 60,
+    maxSize: 60,
+    enableResizing: false,
+    enableSorting: false,
+    enableGrouping: false,
+    enableReordering: false,
+    enableEditing: false,
+    enableFocusing: true,
+    cellDataType: "action-menu",
+    accessorFn: () => null,
+    // Header is empty for action menu column
+    header: () => "",
+    // Cell renderer for action menu - get from plugin registry
+    // The action menu plugin always uses a Component renderer
+    cell: ({ row, cell }) => {
+      const renderer = nuGridCellTypeRegistry.getRenderer("action-menu");
+      if (renderer) {
+        return h(renderer, {
+          row,
+          cell
+        });
+      }
+      return null;
+    },
+    // Store configuration in meta for cell renderer to access
+    meta: requiredMeta
+  };
+  return {
+    ...defaultColumn,
+    ...options.columnDef
+  };
+}
+function parseNuGridActionMenuOptions(options) {
+  if (options === void 0 || options === false) return null;
+  if (typeof options === "object") {
+    const isEnabled = options.enabled === true || options.enabled !== false && options.getActions !== void 0;
+    if (!isEnabled) return null;
+    return {
+      enabled: true,
+      getActions: options.getActions ?? (() => []),
+      isRowEnabled: options.isRowEnabled ?? (() => true),
+      button: { ...defaultButton, ...options.button },
+      hidden: options.hidden ?? false,
+      columnDef: options.columnDef
+    };
+  }
+  return null;
+}
+export function useNuGridActionMenu(actionMenuOptions, columnVisibilityState) {
+  const initialOptions = parseNuGridActionMenuOptions(actionMenuOptions.value);
+  const wasCreatedAtInstantiation = ref(initialOptions !== null);
+  const parsedOptions = computed(() => {
+    return parseNuGridActionMenuOptions(actionMenuOptions.value);
+  });
+  const isCurrentlyConfigured = computed(() => {
+    return parsedOptions.value !== null;
+  });
+  const hasActionMenuColumn = computed(() => {
+    return wasCreatedAtInstantiation.value;
+  });
+  const isHidden = computed(() => {
+    if (!isCurrentlyConfigured.value && wasCreatedAtInstantiation.value) {
+      return true;
+    }
+    return parsedOptions.value?.hidden ?? false;
+  });
+  const isInteractive = computed(() => {
+    if (!isCurrentlyConfigured.value) {
+      return false;
+    }
+    return true;
+  });
+  const menuOpenStates = /* @__PURE__ */ new Map();
+  const actionMenuColumn = wasCreatedAtInstantiation.value && initialOptions ? createActionMenuColumn(initialOptions, isInteractive, menuOpenStates) : null;
+  function appendActionMenuColumn(columns) {
+    if (!actionMenuColumn) return columns;
+    return [...columns, actionMenuColumn];
+  }
+  watch(
+    actionMenuOptions,
+    (newValue) => {
+      const newOptions = parseNuGridActionMenuOptions(newValue);
+      if (newOptions !== null && !wasCreatedAtInstantiation.value) {
+        throw new Error(
+          "Cannot enable action menu after grid instantiation. Action menu must be configured when the grid is created. To start with a hidden action menu column, use: { getActions: fn, hidden: true }"
+        );
+      }
+    },
+    { flush: "sync" }
+  );
+  if (columnVisibilityState) {
+    watch(
+      isHidden,
+      (hidden) => {
+        if (hasActionMenuColumn.value) {
+          columnVisibilityState.value = {
+            ...columnVisibilityState.value,
+            __actions: !hidden
+          };
+        }
+      },
+      { immediate: true }
+    );
+  }
+  return {
+    isEnabled: isCurrentlyConfigured,
+    hasActionMenuColumn,
+    actionMenuColumn,
+    appendActionMenuColumn,
+    isHidden,
+    isInteractive,
+    parsedOptions
+  };
+}

package/dist/runtime/composables/_internal/useNuGridAddRow.d.ts

@@ -0,0 +1,39 @@
+import type { TableColumn, TableData } from '@nuxt/ui';
+import type { GroupingState, Row, Table } from '@tanstack/vue-table';
+import type { ComputedRef, Ref } from 'vue';
+import type { NuGridAddRowFinalizeResult, NuGridAddRowState, NuGridProps } from '../../types/index.js';
+import type { NuGridCellEditing, NuGridEditingCell, NuGridFocus, NuGridGroupingFns, NuGridInteractionRouter } from '../../types/_internal/index.js';
+export declare const ADD_ROW_FLAG = "__nugridAddNewRow";
+type AddRowPosition = 'none' | 'top' | 'bottom';
+export declare function useNuGridAddRow<T extends TableData>(options: {
+    props: NuGridProps<T>;
+    data: Ref<T[]>;
+    table: Table<T>;
+    rows: ComputedRef<Row<T>[]>;
+    columns: ComputedRef<TableColumn<T>[]>;
+    groupingState: Ref<GroupingState>;
+    onAddRowRequested?: (row: T) => NuGridAddRowFinalizeResult & {
+        row?: T;
+    };
+    editingCell?: Ref<NuGridEditingCell | null>;
+    focusFns?: Ref<NuGridFocus<T> | null>;
+    cellEditingFns?: Ref<NuGridCellEditing<T> | null>;
+    groupingFns?: Ref<NuGridGroupingFns<T> | null> | NuGridGroupingFns<T> | null;
+    onAddRowStateChange?: (state: NuGridAddRowState) => void;
+    interactionRouter?: NuGridInteractionRouter<T> | null;
+}): {
+    addRowPosition: ComputedRef<AddRowPosition>;
+    showAddNewRow: ComputedRef<boolean>;
+    addNewText: ComputedRef<string>;
+    refreshAddRows: () => void;
+    isAddRowRow: (row: Row<T>) => boolean;
+    orderedRows: ComputedRef<Row<T>[]>;
+    getAddRowRow: () => Row<T> | null;
+    getGroupAddRow: (groupId: string) => Row<T> | null;
+    finalizeAddRow: (row: Row<T>) => NuGridAddRowFinalizeResult;
+    resetAddRow: (row: Row<T>) => void;
+    addRowState: ComputedRef<NuGridAddRowState>;
+    isFinalizing: Ref<boolean, boolean>;
+    finalizingRowId: Ref<string | null, string | null>;
+};
+export {};