nuxt-ui-tools 0.1.0

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

@@ -0,0 +1,72 @@
+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";
+import { useSpreadsheetRows } from "./use-spreadsheet-rows.js";
+import { useSpreadsheetSource } from "./use-spreadsheet-source.js";
+function resolveSpreadsheetSchemaSource(schema) {
+  return toValue(schema);
+}
+function resolveSpreadsheetValue(value) {
+  return toValue(value);
+}
+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
+    )
+  });
+  const context = useSpreadsheetContext({
+    schema
+  });
+  const rows = useSpreadsheetRows({
+    schema,
+    contextData: context.contextData,
+    headers: source.headers,
+    rows: source.rows
+  });
+  const resolutions = useSpreadsheetResolutions({
+    schema,
+    contextData: context.contextData,
+    rows: computed(() => rows.parsedRows.value)
+  });
+  return {
+    schema,
+    source,
+    context,
+    rows,
+    resolutions,
+    references: resolutions
+  };
+}
+const SPREADSHEET_INTERNALS_KEY = Symbol(
+  "nuxt-ui-tools.spreadsheet.internals"
+);
+function provideSpreadsheetInternals(internals) {
+  provide(SPREADSHEET_INTERNALS_KEY, internals);
+}
+function useProvideSpreadsheetInternals(options) {
+  const internals = createSpreadsheetInternals(options);
+  provideSpreadsheetInternals(internals);
+  return internals;
+}
+function useSpreadsheetInternals() {
+  const internals = inject(SPREADSHEET_INTERNALS_KEY, null);
+  if (!internals)
+    throw new Error("useSpreadsheetInternals must be called inside a spreadsheet provider");
+  return internals;
+}
+export {
+  createSpreadsheetInternals,
+  provideSpreadsheetInternals,
+  useProvideSpreadsheetInternals,
+  useSpreadsheetInternals
+};

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

@@ -0,0 +1 @@
+export { useSpreadsheetResolutions as useSpreadsheetReferences, type UseSpreadsheetResolutionsParams as UseSpreadsheetReferencesParams, } from './use-spreadsheet-resolutions.js';

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

@@ -0,0 +1,3 @@
+export {
+  useSpreadsheetResolutions as useSpreadsheetReferences
+} from "./use-spreadsheet-resolutions.js";

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

@@ -0,0 +1,40 @@
+import { type ComputedRef } from 'vue';
+import type { SpreadsheetNormalizedSchema, SpreadsheetParsedRow, SpreadsheetReferenceResolution } from '../types/index.js';
+export interface UseSpreadsheetResolutionsParams {
+    schema: ComputedRef<SpreadsheetNormalizedSchema>;
+    contextData: ComputedRef<Record<string, unknown>>;
+    rows: ComputedRef<readonly SpreadsheetParsedRow<Record<string, unknown>>[]>;
+}
+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;
+        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>[]>;
+    selectReference: (selection: {
+        referenceField: string;
+        sourceValue: string;
+        selectedValue: unknown;
+        selectedLabel: string;
+    }) => void;
+    clearReference: (selection: {
+        referenceField: string;
+        sourceValue: string;
+    }) => void;
+};

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

@@ -0,0 +1,95 @@
+import { computed, shallowRef, watch } from "vue";
+import {
+  applySpreadsheetReferenceResolutions,
+  createSpreadsheetReferenceQueryRequests,
+  createSpreadsheetReferenceResolutions
+} from "../utils/index.js";
+function createResolutionId(resolution) {
+  return `${resolution.targetField ?? resolution.referenceField}::${resolution.sourceValue}`;
+}
+export function useSpreadsheetResolutions(params) {
+  const resolutionDefinitions = computed(
+    () => params.schema.value.resolutions ?? params.schema.value.references ?? []
+  );
+  const autoResolutions = computed(
+    () => createSpreadsheetReferenceResolutions({
+      references: resolutionDefinitions.value,
+      rows: params.rows.value,
+      context: params.contextData.value
+    })
+  );
+  const manualSelections = shallowRef({});
+  const resolutions = computed(
+    () => autoResolutions.value.map((resolution) => {
+      const manual = manualSelections.value[createResolutionId(resolution)];
+      return manual ?? resolution;
+    })
+  );
+  const unresolvedResolutions = computed(
+    () => resolutions.value.filter((resolution) => resolution.status === "unresolved")
+  );
+  const resolvedRows = computed(
+    () => applySpreadsheetReferenceResolutions({
+      rows: params.rows.value,
+      references: resolutionDefinitions.value,
+      resolutions: resolutions.value,
+      relations: params.schema.value.relations
+    })
+  );
+  const queryRequests = computed(
+    () => createSpreadsheetReferenceQueryRequests({
+      references: resolutionDefinitions.value,
+      rows: params.rows.value,
+      context: params.contextData.value
+    })
+  );
+  const status = computed(() => ({
+    initialized: true,
+    isReady: true,
+    unresolvedCount: unresolvedResolutions.value.length
+  }));
+  function selectResolution(selection) {
+    const key = `${selection.resolutionField}::${selection.sourceValue}`;
+    const current = resolutions.value.find((resolution) => createResolutionId(resolution) === key);
+    if (!current) return;
+    manualSelections.value = {
+      ...manualSelections.value,
+      [key]: {
+        ...current,
+        status: "matched",
+        selectedValue: selection.selectedValue,
+        selectedLabel: selection.selectedLabel
+      }
+    };
+  }
+  function clearResolution(selection) {
+    const key = `${selection.resolutionField}::${selection.sourceValue}`;
+    const nextSelections = { ...manualSelections.value };
+    delete nextSelections[key];
+    manualSelections.value = nextSelections;
+  }
+  watch(resolutionDefinitions, () => {
+    manualSelections.value = {};
+  });
+  return {
+    resolutionDefinitions,
+    resolutions,
+    unresolvedResolutions,
+    resolvedRows,
+    queryRequests,
+    status,
+    selectResolution,
+    clearResolution,
+    referenceDefinitions: resolutionDefinitions,
+    selectReference: (selection) => selectResolution({
+      resolutionField: selection.referenceField,
+      sourceValue: selection.sourceValue,
+      selectedValue: selection.selectedValue,
+      selectedLabel: selection.selectedLabel
+    }),
+    clearReference: (selection) => clearResolution({
+      resolutionField: selection.referenceField,
+      sourceValue: selection.sourceValue
+    })
+  };
+}

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

@@ -0,0 +1,173 @@
+import { type ComputedRef } from 'vue';
+import type { 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>;
+}
+export interface UseSpreadsheetReviewParams {
+    resolvedRows: ComputedRef<readonly SpreadsheetResolvedReferenceRow<Record<string, unknown>>[]>;
+    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;
+        label: string;
+        hint: string;
+        valueClass: string;
+        accentClass: string;
+        cardClass: string;
+    }[]>;
+    hasOverflow: ComputedRef<boolean>;
+    overflowCount: ComputedRef<number>;
+    tabItems: ComputedRef<({
+        key: "all";
+        label: string;
+    } | {
+        key: "valid";
+        label: string;
+    } | {
+        key: "invalid";
+        label: string;
+    } | {
+        key: "discarded";
+        label: string;
+    })[]>;
+    issueFilterItems: ComputedRef<({
+        key: "all";
+        label: string;
+    } | {
+        key: "blocking";
+        label: string;
+    } | {
+        key: "warning";
+        label: string;
+    })[]>;
+    canDiscardSelection: ComputedRef<boolean>;
+    canRestoreSelection: ComputedRef<boolean>;
+    reviewTableColumns: ComputedRef<({
+        id: string;
+        header: string;
+        accessorFn: (row: {
+            data: Record<string, unknown>;
+        }) => string;
+        cell: ({ row }: {
+            row: {
+                original: {
+                    data: Record<string, unknown>;
+                };
+            };
+        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        meta: {
+            class: {
+                th: string;
+                td: string;
+            };
+        };
+    } | {
+        id: string;
+        header: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        cell: ({ row }: {
+            row: {
+                original: {
+                    index: number;
+                };
+            };
+        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        meta: {
+            class: {
+                th: string;
+                td: string;
+            };
+        };
+        accessorFn?: undefined;
+    } | {
+        id: string;
+        header: string;
+        accessorFn: (row: {
+            index: number;
+        }) => number;
+        cell: ({ row, }: {
+            row: {
+                original: {
+                    index: number;
+                    issues: readonly SpreadsheetRowIssue[];
+                };
+            };
+        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        meta: {
+            class: {
+                th: string;
+                td: string;
+            };
+        };
+    })[]>;
+    tableColumns: ComputedRef<string[]>;
+    formatSpreadsheetCell: typeof formatSpreadsheetCell;
+    getSpreadsheetObjectEntries: typeof getSpreadsheetObjectEntries;
+    humanizeSpreadsheetKey: typeof humanizeSpreadsheetKey;
+    getIssueBadge: (issue: SpreadsheetRowIssue) => {
+        label: string;
+        color: "error";
+    } | {
+        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[]) => {
+        label: string;
+        color: "neutral";
+        icon: string;
+    } | {
+        label: string;
+        color: "error";
+        icon: string;
+    } | {
+        label: string;
+        color: "warning";
+        icon: string;
+    } | {
+        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;
+};
+export {};