nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/spreadsheet/composables/use-spreadsheet-internals.js

@@ -1,9 +1,4 @@
-import {
-  computed,
-  inject,
-  provide,
-  toValue
-} from "vue";
+import { computed, inject, provide, toValue } from "vue";
 import { normalizeSpreadsheetSchema } from "../schema/index.js";
 import { useSpreadsheetContext } from "./use-spreadsheet-context.js";
 import { useSpreadsheetResolutions } from "./use-spreadsheet-resolutions.js";
@@ -19,32 +14,32 @@ function createSpreadsheetInternals(options) {
   const publicSchema = computed(() => resolveSpreadsheetSchemaSource(options.rawSchema));
   const schema = computed(() => normalizeSpreadsheetSchema(publicSchema.value));
   const source = useSpreadsheetSource({
-    source: options.source,
     fileName: computed(
       () => options.fileName ? resolveSpreadsheetValue(options.fileName) : void 0
-    )
+    ),
+    source: options.source
   });
   const context = useSpreadsheetContext({
     schema
   });
   const rows = useSpreadsheetRows({
-    schema,
     contextData: context.contextData,
     headers: source.headers,
-    rows: source.rows
+    rows: source.rows,
+    schema
   });
   const resolutions = useSpreadsheetResolutions({
-    schema,
     contextData: context.contextData,
-    rows: computed(() => rows.parsedRows.value)
+    rows: computed(() => rows.parsedRows.value),
+    schema
   });
   return {
-    schema,
-    source,
     context,
-    rows,
+    references: resolutions,
     resolutions,
-    references: resolutions
+    rows,
+    schema,
+    source
   };
 }
 const SPREADSHEET_INTERNALS_KEY = Symbol(
@@ -60,8 +55,9 @@ function useProvideSpreadsheetInternals(options) {
 }
 function useSpreadsheetInternals() {
   const internals = inject(SPREADSHEET_INTERNALS_KEY, null);
-  if (!internals)
+  if (!internals) {
     throw new Error("useSpreadsheetInternals must be called inside a spreadsheet provider");
+  }
   return internals;
 }
 export {

package/dist/runtime/spreadsheet/composables/use-spreadsheet-resolutions.d.ts

@@ -1,40 +1,40 @@
-import { type ComputedRef } from 'vue';
-import type { SpreadsheetNormalizedSchema, SpreadsheetParsedRow, SpreadsheetReferenceResolution } from '../types/index.js';
+import type { ComputedRef } from 'vue';
+import type { SpreadsheetNormalizedSchema, SpreadsheetParsedRow, SpreadsheetRecord, SpreadsheetReferenceResolution } from '../types/index.js';
 export interface UseSpreadsheetResolutionsParams {
     schema: ComputedRef<SpreadsheetNormalizedSchema>;
-    contextData: ComputedRef<Record<string, unknown>>;
-    rows: ComputedRef<readonly SpreadsheetParsedRow<Record<string, unknown>>[]>;
+    contextData: ComputedRef<SpreadsheetRecord>;
+    rows: ComputedRef<readonly SpreadsheetParsedRow<SpreadsheetRecord>[]>;
 }
 export declare function useSpreadsheetResolutions(params: UseSpreadsheetResolutionsParams): {
-    resolutionDefinitions: ComputedRef<readonly import("../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, Record<string, unknown>, Record<string, unknown>, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[]>;
-    resolutions: ComputedRef<SpreadsheetReferenceResolution<unknown, unknown>[]>;
-    unresolvedResolutions: ComputedRef<SpreadsheetReferenceResolution<unknown, unknown>[]>;
-    resolvedRows: ComputedRef<import("../types/index.js").SpreadsheetResolvedReferenceRow<Record<string, unknown>>[]>;
-    queryRequests: ComputedRef<import("../types/index.js").SpreadsheetReferenceQueryRequest[]>;
-    status: ComputedRef<{
-        initialized: boolean;
-        isReady: boolean;
-        unresolvedCount: number;
-    }>;
-    selectResolution: (selection: {
-        resolutionField: string;
+    clearReference: (selection: {
+        referenceField: string;
         sourceValue: string;
-        selectedValue: unknown;
-        selectedLabel: string;
     }) => void;
     clearResolution: (selection: {
         resolutionField: string;
         sourceValue: string;
     }) => void;
-    referenceDefinitions: ComputedRef<readonly import("../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, Record<string, unknown>, Record<string, unknown>, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[]>;
+    queryRequests: ComputedRef<import("../types/index.js").SpreadsheetReferenceQueryRequest[]>;
+    referenceDefinitions: ComputedRef<readonly import("../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, SpreadsheetRecord, SpreadsheetRecord, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[]>;
+    resolutionDefinitions: ComputedRef<readonly import("../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, SpreadsheetRecord, SpreadsheetRecord, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[]>;
+    resolutions: ComputedRef<SpreadsheetReferenceResolution<unknown, unknown>[]>;
+    resolvedRows: ComputedRef<import("../types/index.js").SpreadsheetResolvedReferenceRow<SpreadsheetRecord>[]>;
     selectReference: (selection: {
         referenceField: string;
         sourceValue: string;
         selectedValue: unknown;
         selectedLabel: string;
     }) => void;
-    clearReference: (selection: {
-        referenceField: string;
+    selectResolution: (selection: {
+        resolutionField: string;
         sourceValue: string;
+        selectedValue: unknown;
+        selectedLabel: string;
     }) => void;
+    status: ComputedRef<{
+        initialized: boolean;
+        isReady: boolean;
+        unresolvedCount: number;
+    }>;
+    unresolvedResolutions: ComputedRef<SpreadsheetReferenceResolution<unknown, unknown>[]>;
 };

package/dist/runtime/spreadsheet/composables/use-spreadsheet-resolutions.js

@@ -13,9 +13,9 @@ export function useSpreadsheetResolutions(params) {
   );
   const autoResolutions = computed(
     () => createSpreadsheetReferenceResolutions({
+      context: params.contextData.value,
       references: resolutionDefinitions.value,
-      rows: params.rows.value,
-      context: params.contextData.value
+      rows: params.rows.value
     })
   );
   const manualSelections = shallowRef({});
@@ -30,17 +30,17 @@ export function useSpreadsheetResolutions(params) {
   );
   const resolvedRows = computed(
     () => applySpreadsheetReferenceResolutions({
-      rows: params.rows.value,
       references: resolutionDefinitions.value,
+      relations: params.schema.value.relations,
       resolutions: resolutions.value,
-      relations: params.schema.value.relations
+      rows: params.rows.value
     })
   );
   const queryRequests = computed(
     () => createSpreadsheetReferenceQueryRequests({
+      context: params.contextData.value,
       references: resolutionDefinitions.value,
-      rows: params.rows.value,
-      context: params.contextData.value
+      rows: params.rows.value
     })
   );
   const status = computed(() => ({
@@ -51,14 +51,16 @@ export function useSpreadsheetResolutions(params) {
   function selectResolution(selection) {
     const key = `${selection.resolutionField}::${selection.sourceValue}`;
     const current = resolutions.value.find((resolution) => createResolutionId(resolution) === key);
-    if (!current) return;
+    if (!current) {
+      return;
+    }
     manualSelections.value = {
       ...manualSelections.value,
       [key]: {
         ...current,
-        status: "matched",
+        selectedLabel: selection.selectedLabel,
         selectedValue: selection.selectedValue,
-        selectedLabel: selection.selectedLabel
+        status: "matched"
       }
     };
   }
@@ -72,24 +74,24 @@ export function useSpreadsheetResolutions(params) {
     manualSelections.value = {};
   });
   return {
+    clearReference: (selection) => clearResolution({
+      resolutionField: selection.referenceField,
+      sourceValue: selection.sourceValue
+    }),
+    clearResolution,
+    queryRequests,
+    referenceDefinitions: resolutionDefinitions,
     resolutionDefinitions,
     resolutions,
-    unresolvedResolutions,
     resolvedRows,
-    queryRequests,
-    status,
-    selectResolution,
-    clearResolution,
-    referenceDefinitions: resolutionDefinitions,
     selectReference: (selection) => selectResolution({
       resolutionField: selection.referenceField,
-      sourceValue: selection.sourceValue,
+      selectedLabel: selection.selectedLabel,
       selectedValue: selection.selectedValue,
-      selectedLabel: selection.selectedLabel
-    }),
-    clearReference: (selection) => clearResolution({
-      resolutionField: selection.referenceField,
       sourceValue: selection.sourceValue
-    })
+    }),
+    selectResolution,
+    status,
+    unresolvedResolutions
   };
 }

package/dist/runtime/spreadsheet/composables/use-spreadsheet-review.d.ts

@@ -1,49 +1,67 @@
-import { type ComputedRef } from 'vue';
-import type { SpreadsheetRowIssue, SpreadsheetResolvedReferenceRow } from '../types/index.js';
+import type { ComputedRef } from 'vue';
+import type { SpreadsheetRecord, SpreadsheetRowIssue, SpreadsheetResolvedReferenceRow } from '../types/index.js';
 import { formatSpreadsheetCell, humanizeSpreadsheetKey } from '../utils/display.js';
 import { getSpreadsheetObjectEntries } from '../utils/object.js';
 export type SpreadsheetReviewTab = 'all' | 'valid' | 'invalid' | 'discarded';
 export type SpreadsheetReviewIssueFilter = 'all' | 'blocking' | 'warning';
-interface SpreadsheetReviewRow extends SpreadsheetResolvedReferenceRow<Record<string, unknown>> {
-    rowObject: Record<string, unknown>;
+interface SpreadsheetReviewRow extends SpreadsheetResolvedReferenceRow<SpreadsheetRecord> {
+    rowObject: SpreadsheetRecord;
 }
 export interface UseSpreadsheetReviewParams {
-    resolvedRows: ComputedRef<readonly SpreadsheetResolvedReferenceRow<Record<string, unknown>>[]>;
+    resolvedRows: ComputedRef<readonly SpreadsheetResolvedReferenceRow<SpreadsheetRecord>[]>;
     maxRecords: ComputedRef<number>;
 }
 export declare function useSpreadsheetReview(params: UseSpreadsheetReviewParams): {
     activeTab: import("vue").Ref<SpreadsheetReviewTab, SpreadsheetReviewTab>;
-    issueFilter: import("vue").Ref<SpreadsheetReviewIssueFilter, SpreadsheetReviewIssueFilter>;
-    inspectedRow: ComputedRef<SpreadsheetReviewRow | null>;
-    inspectedIssueRowPosition: ComputedRef<number>;
-    issueRows: ComputedRef<SpreadsheetReviewRow[]>;
-    rowSelection: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
-    selectedRowIndexes: ComputedRef<number[]>;
-    visibleRows: ComputedRef<SpreadsheetReviewRow[]>;
-    stats: ComputedRef<{
-        key: string;
-        value: number;
+    canDiscardSelection: ComputedRef<boolean>;
+    canRestoreSelection: ComputedRef<boolean>;
+    closeInspection: () => void;
+    discardRow: (index: number) => void;
+    discardSelectedRows: () => void;
+    formatSpreadsheetCell: typeof formatSpreadsheetCell;
+    getIssueBadge: (issue: SpreadsheetRowIssue) => {
+        color: "error";
         label: string;
-        hint: string;
-        valueClass: string;
-        accentClass: string;
-        cardClass: string;
-    }[]>;
-    hasOverflow: ComputedRef<boolean>;
-    overflowCount: ComputedRef<number>;
-    tabItems: ComputedRef<({
-        key: "all";
+    } | {
+        color: "warning";
+        label: string;
+    };
+    getIssueRawValue: (rowData: SpreadsheetRecord, issue: SpreadsheetRowIssue) => unknown;
+    getIssueValue: (rowData: SpreadsheetRecord, issue: SpreadsheetRowIssue) => string;
+    getIssueValueTone: (issue: SpreadsheetRowIssue) => "bg-error/6" | "bg-warning/10";
+    getRelatedIssueCount: (issue: SpreadsheetRowIssue) => number;
+    getRowStatus: (index: number, issues: readonly SpreadsheetRowIssue[]) => {
+        color: "neutral";
+        icon: string;
         label: string;
     } | {
-        key: "valid";
+        color: "error";
+        icon: string;
         label: string;
     } | {
-        key: "invalid";
+        color: "warning";
+        icon: string;
         label: string;
     } | {
-        key: "discarded";
+        color: "success";
+        icon: string;
         label: string;
-    })[]>;
+    };
+    getRowToneClass: (row: {
+        index: number;
+        issues: readonly SpreadsheetRowIssue[];
+    }) => "" | "opacity-45" | "bg-error/5" | "bg-warning/5";
+    getSpreadsheetObjectEntries: typeof getSpreadsheetObjectEntries;
+    hasOverflow: ComputedRef<boolean>;
+    humanizeSpreadsheetKey: typeof humanizeSpreadsheetKey;
+    inspectNextIssueRow: () => void;
+    inspectPrevIssueRow: () => void;
+    inspectRow: (index: number) => void;
+    inspectedIssueRowPosition: ComputedRef<number>;
+    inspectedRow: ComputedRef<SpreadsheetReviewRow | null>;
+    isDiscarded: (index: number) => boolean;
+    isManuallyDiscarded: (index: number) => boolean;
+    issueFilter: import("vue").Ref<SpreadsheetReviewIssueFilter, SpreadsheetReviewIssueFilter>;
     issueFilterItems: ComputedRef<({
         key: "all";
         label: string;
@@ -54,34 +72,32 @@ export declare function useSpreadsheetReview(params: UseSpreadsheetReviewParams)
         key: "warning";
         label: string;
     })[]>;
-    canDiscardSelection: ComputedRef<boolean>;
-    canRestoreSelection: ComputedRef<boolean>;
+    issueRows: ComputedRef<SpreadsheetReviewRow[]>;
+    overflowCount: ComputedRef<number>;
+    restoreRow: (index: number) => void;
+    restoreSelectedRows: () => void;
     reviewTableColumns: ComputedRef<({
-        id: string;
-        header: string;
         accessorFn: (row: {
-            data: Record<string, unknown>;
+            data: SpreadsheetRecord;
         }) => string;
         cell: ({ row }: {
             row: {
                 original: {
-                    data: Record<string, unknown>;
+                    data: SpreadsheetRecord;
                 };
             };
         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
             [key: string]: any;
         }>;
+        header: string;
+        id: string;
         meta: {
             class: {
-                th: string;
                 td: string;
+                th: string;
             };
         };
     } | {
-        id: string;
-        header: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>;
         cell: ({ row }: {
             row: {
                 original: {
@@ -91,16 +107,18 @@ export declare function useSpreadsheetReview(params: UseSpreadsheetReviewParams)
         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
             [key: string]: any;
         }>;
+        header: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        id: string;
         meta: {
             class: {
-                th: string;
                 td: string;
+                th: string;
             };
         };
         accessorFn?: undefined;
     } | {
-        id: string;
-        header: string;
         accessorFn: (row: {
             index: number;
         }) => number;
@@ -114,60 +132,42 @@ export declare function useSpreadsheetReview(params: UseSpreadsheetReviewParams)
         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
             [key: string]: any;
         }>;
+        header: string;
+        id: string;
         meta: {
             class: {
-                th: string;
                 td: string;
+                th: string;
             };
         };
     })[]>;
-    tableColumns: ComputedRef<string[]>;
-    formatSpreadsheetCell: typeof formatSpreadsheetCell;
-    getSpreadsheetObjectEntries: typeof getSpreadsheetObjectEntries;
-    humanizeSpreadsheetKey: typeof humanizeSpreadsheetKey;
-    getIssueBadge: (issue: SpreadsheetRowIssue) => {
-        label: string;
-        color: "error";
-    } | {
+    rowSelection: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
+    selectedRowIndexes: ComputedRef<number[]>;
+    setActiveTab: (value: SpreadsheetReviewTab) => void;
+    setIssueFilter: (value: SpreadsheetReviewIssueFilter) => void;
+    stats: ComputedRef<{
+        accentClass: string;
+        cardClass: string;
+        hint: string;
+        key: string;
         label: string;
-        color: "warning";
-    };
-    getIssueValueTone: (issue: SpreadsheetRowIssue) => "bg-error/6" | "bg-warning/10";
-    getIssueValue: (rowData: Record<string, unknown>, issue: SpreadsheetRowIssue) => string;
-    getIssueRawValue: (rowData: Record<string, unknown>, issue: SpreadsheetRowIssue) => unknown;
-    getRelatedIssueCount: (issue: SpreadsheetRowIssue) => number;
-    getRowToneClass: (row: {
-        index: number;
-        issues: readonly SpreadsheetRowIssue[];
-    }) => "" | "opacity-45" | "bg-error/5" | "bg-warning/5";
-    getRowStatus: (index: number, issues: readonly SpreadsheetRowIssue[]) => {
+        value: number;
+        valueClass: string;
+    }[]>;
+    tabItems: ComputedRef<({
+        key: "all";
         label: string;
-        color: "neutral";
-        icon: string;
     } | {
+        key: "valid";
         label: string;
-        color: "error";
-        icon: string;
     } | {
+        key: "invalid";
         label: string;
-        color: "warning";
-        icon: string;
     } | {
+        key: "discarded";
         label: string;
-        color: "success";
-        icon: string;
-    };
-    setActiveTab: (value: SpreadsheetReviewTab) => void;
-    setIssueFilter: (value: SpreadsheetReviewIssueFilter) => void;
-    discardSelectedRows: () => void;
-    restoreSelectedRows: () => void;
-    discardRow: (index: number) => void;
-    restoreRow: (index: number) => void;
-    inspectRow: (index: number) => void;
-    closeInspection: () => void;
-    inspectPrevIssueRow: () => void;
-    inspectNextIssueRow: () => void;
-    isDiscarded: (index: number) => boolean;
-    isManuallyDiscarded: (index: number) => boolean;
+    })[]>;
+    tableColumns: ComputedRef<string[]>;
+    visibleRows: ComputedRef<SpreadsheetReviewRow[]>;
 };
 export {};