nuxt-ui-tools 0.1.0

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

@@ -0,0 +1,15 @@
+import type { SpreadsheetStepItem } from '../components/types.js';
+import type { SpreadsheetStepsDefinition } from '../types/index.js';
+export declare function useSpreadsheetView(params: {
+    hasReferences: () => boolean;
+    stepConfig?: () => SpreadsheetStepsDefinition | undefined;
+    t: (path: string, option?: Record<string, string | number>) => string;
+}): {
+    steps: import("vue").ComputedRef<SpreadsheetStepItem[]>;
+    activeStep: import("vue").Ref<string, string>;
+    activeStepIndex: import("vue").ComputedRef<number>;
+    canGoPrev: import("vue").ComputedRef<boolean>;
+    canGoNext: import("vue").ComputedRef<boolean>;
+    goToNextStep: () => void;
+    goToPrevStep: () => void;
+};

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

@@ -0,0 +1,103 @@
+import { computed, ref, watch } from "vue";
+import { resolveTextValue } from "#ui-tools/shared/utils/render";
+export function useSpreadsheetView(params) {
+  const activeStep = ref("upload");
+  const steps = computed(() => [
+    {
+      value: "upload",
+      title: resolveTextValue(
+        params.stepConfig?.()?.upload?.title,
+        params.t("spreadsheet.steps.upload.title")
+      ),
+      description: resolveTextValue(
+        params.stepConfig?.()?.upload?.description,
+        params.t("spreadsheet.steps.upload.description")
+      ),
+      icon: "i-lucide-upload"
+    },
+    {
+      value: "structure",
+      title: resolveTextValue(
+        params.stepConfig?.()?.structure?.title,
+        params.t("spreadsheet.steps.structure.title")
+      ),
+      description: resolveTextValue(
+        params.stepConfig?.()?.structure?.description,
+        params.t("spreadsheet.steps.structure.description")
+      ),
+      icon: "i-lucide-table-properties"
+    },
+    {
+      value: "matching",
+      title: resolveTextValue(
+        params.stepConfig?.()?.matching?.title,
+        params.t("spreadsheet.steps.matching.title")
+      ),
+      description: resolveTextValue(
+        params.stepConfig?.()?.matching?.description,
+        params.t("spreadsheet.steps.matching.description")
+      ),
+      icon: "i-lucide-columns-3"
+    },
+    ...params.hasReferences() ? [
+      {
+        value: "references",
+        title: resolveTextValue(
+          params.stepConfig?.()?.references?.title,
+          params.t("spreadsheet.steps.references.title")
+        ),
+        description: resolveTextValue(
+          params.stepConfig?.()?.references?.description,
+          params.t("spreadsheet.steps.references.description")
+        ),
+        icon: "i-lucide-link-2"
+      }
+    ] : [],
+    {
+      value: "review",
+      title: resolveTextValue(
+        params.stepConfig?.()?.review?.title,
+        params.t("spreadsheet.steps.review.title")
+      ),
+      description: resolveTextValue(
+        params.stepConfig?.()?.review?.description,
+        params.t("spreadsheet.steps.review.description")
+      ),
+      icon: "i-lucide-clipboard-check"
+    }
+  ]);
+  const activeStepIndex = computed(
+    () => steps.value.findIndex((step) => step.value === activeStep.value)
+  );
+  const canGoPrev = computed(() => activeStepIndex.value > 0);
+  const canGoNext = computed(
+    () => activeStepIndex.value >= 0 && activeStepIndex.value < steps.value.length - 1
+  );
+  function goToNextStep() {
+    if (!canGoNext.value) return;
+    activeStep.value = steps.value[activeStepIndex.value + 1]?.value ?? activeStep.value;
+  }
+  function goToPrevStep() {
+    if (!canGoPrev.value) return;
+    activeStep.value = steps.value[activeStepIndex.value - 1]?.value ?? activeStep.value;
+  }
+  watch(
+    steps,
+    (nextSteps) => {
+      if (nextSteps.some((step) => step.value === activeStep.value)) return;
+      activeStep.value = nextSteps[0]?.value ?? "upload";
+    },
+    {
+      immediate: true
+    }
+  );
+  return {
+    steps,
+    activeStep,
+    activeStepIndex,
+    canGoPrev,
+    canGoNext,
+    goToNextStep,
+    goToPrevStep
+  };
+}

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

@@ -0,0 +1,4 @@
+export * from './composables/index.js';
+export * from './schema/index.js';
+export * from './utils/index.js';
+export type * from './types';

package/dist/runtime/spreadsheet/index.js

@@ -0,0 +1,3 @@
+export * from "./composables/index.js";
+export * from "./schema/index.js";
+export * from "./utils/index.js";

package/dist/runtime/spreadsheet/schema/index.d.ts

@@ -0,0 +1,32 @@
+import type { SpreadsheetColumnsDefinition, SpreadsheetContextDataFromItems, SpreadsheetContextItem, SpreadsheetFileDefinition, SpreadsheetHeaderStepDefinition, SpreadsheetMatchingStepDefinition, SpreadsheetReferenceBuilder, SpreadsheetSchemaWithRefine, SpreadsheetResolvedColumns, SpreadsheetReviewStepDefinition, SpreadsheetRowData, SpreadsheetSheetStepDefinition, SpreadsheetStepsDefinition } from '../types/index.js';
+type SpreadsheetResolvedColumnsInput<TColumns> = [TColumns] extends [
+    SpreadsheetColumnsDefinition<any>
+] ? SpreadsheetResolvedColumns<TColumns> : undefined;
+type SpreadsheetExtractedReference<TValue> = Extract<TValue, import('../types').SpreadsheetReferenceDefinition<any, any, any>>;
+type SpreadsheetResolvedReferences<TReferences> = TReferences extends (...args: infer _Args) => infer TResult ? TResult extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TResult[number]>[] : readonly [] : TReferences extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TReferences[number]>[] : readonly [];
+type SpreadsheetSchemaDefinition<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = {
+    importKey: TImportKey;
+    file?: SpreadsheetFileDefinition;
+    sheet?: SpreadsheetSheetStepDefinition;
+    header?: SpreadsheetHeaderStepDefinition;
+    matching?: SpreadsheetMatchingStepDefinition;
+    steps?: SpreadsheetStepsDefinition;
+    review?: SpreadsheetReviewStepDefinition;
+    context?: TContextItems;
+    columns?: TColumns;
+    references?: TReferences;
+    buildRow?: TBuildRow;
+};
+type SpreadsheetBuildRowInput<TContext, TRow, TResult> = (params: {
+    context: TContext;
+    row: TRow;
+}) => TResult | Promise<TResult>;
+type SpreadsheetSchemaReturn<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = Omit<SpreadsheetSchemaDefinition<TImportKey, TContextItems, TColumns, TReferences, TBuildRow>, 'columns'> & {
+    columns?: SpreadsheetResolvedColumnsInput<TColumns>;
+    __columnsInput?: TColumns;
+};
+type SpreadsheetDefinedSchemaReturn<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = SpreadsheetSchemaWithRefine<SpreadsheetSchemaReturn<TImportKey, TContextItems, TColumns, TReferences, TBuildRow>>;
+export declare function defineSpreadsheetSchema<const TImportKey extends string, const TContextItems extends readonly SpreadsheetContextItem<string, unknown>[] = readonly [], TContextData = SpreadsheetContextDataFromItems<TContextItems>, const TColumns extends SpreadsheetColumnsDefinition<TContextData> | undefined = SpreadsheetColumnsDefinition<TContextData> | undefined, const TReferences extends readonly unknown[] | undefined = readonly unknown[] | undefined, TReferenceRow = SpreadsheetRowData<SpreadsheetResolvedColumnsInput<TColumns>, readonly []>, TResolvedReferences = SpreadsheetResolvedReferences<TReferences>, TFinalRow = SpreadsheetRowData<SpreadsheetResolvedColumnsInput<TColumns>, TResolvedReferences>, TBuildRowResult = never>(schema: SpreadsheetSchemaDefinition<TImportKey, TContextItems, TColumns, TReferences | ((reference: SpreadsheetReferenceBuilder<TReferenceRow>) => TReferences), SpreadsheetBuildRowInput<TContextData, TFinalRow, TBuildRowResult> | undefined> & {
+    relations?: undefined;
+}): SpreadsheetDefinedSchemaReturn<TImportKey, TContextItems, TColumns, TReferences, SpreadsheetBuildRowInput<TContextData, TFinalRow, TBuildRowResult> | undefined>;
+export * from './normalize.js';

package/dist/runtime/spreadsheet/schema/index.js

@@ -0,0 +1,20 @@
+import { resolveSpreadsheetColumns } from "../utils/builders/index.js";
+function withSpreadsheetRefine(schema) {
+  return {
+    ...schema,
+    refine(refinement) {
+      return withSpreadsheetRefine({
+        ...schema,
+        relations: refinement.relations
+      });
+    }
+  };
+}
+export function defineSpreadsheetSchema(schema) {
+  if (!schema.columns) return withSpreadsheetRefine(schema);
+  return withSpreadsheetRefine({
+    ...schema,
+    columns: resolveSpreadsheetColumns(schema.columns)
+  });
+}
+export * from "./normalize.js";

package/dist/runtime/spreadsheet/schema/normalize.d.ts

@@ -0,0 +1,73 @@
+import type { NormalizeSpreadsheetSchema, SpreadsheetResolutionDefinition, SpreadsheetColumnsDefinition, SpreadsheetContextItem, SpreadsheetDynamicBuilder } from '../types/index.js';
+export declare function resolveSpreadsheetDynamicColumns<TContext, TResult extends readonly unknown[]>(columns: {
+    dynamic: (params: {
+        dynamic: SpreadsheetDynamicBuilder<TContext>;
+        context: TContext;
+    }) => TResult;
+}, context: TContext): TResult;
+export declare function resolveSpreadsheetDynamicColumns<TContext>(columns: {
+    dynamic?: ((params: {
+        dynamic: SpreadsheetDynamicBuilder;
+        context: TContext;
+    }) => readonly unknown[]) | undefined;
+}, context: TContext): readonly [];
+export declare function resolveSpreadsheetBuildRow<TBuildRow>(buildRow: TBuildRow): TBuildRow;
+export declare function resolveSpreadsheetBuildRow(buildRow: undefined): undefined;
+export declare function normalizeSpreadsheetSchema<TSchema extends {
+    importKey: string;
+    file?: unknown;
+    sheet?: unknown;
+    header?: unknown;
+    matching?: unknown;
+    review?: unknown;
+    steps?: unknown;
+    context?: readonly SpreadsheetContextItem<string, unknown>[];
+    columns?: SpreadsheetColumnsDefinition<any>;
+    references?: unknown;
+    relations?: readonly unknown[];
+    buildRow?: unknown;
+}>(schema: TSchema): TSchema & {
+    sheet: {
+        [x: string]: unknown;
+    };
+    header: {
+        [x: string]: unknown;
+    };
+    matching: {
+        [x: string]: unknown;
+    };
+    review: {
+        [x: string]: unknown;
+    };
+    steps: {
+        upload: Record<string, unknown>;
+        structure: {
+            sheet: {
+                [x: string]: unknown;
+            };
+            header: {
+                [x: string]: unknown;
+            };
+        };
+        matching: {
+            [x: string]: unknown;
+        };
+        references: Record<string, unknown>;
+        review: {
+            [x: string]: unknown;
+        };
+    };
+    context: readonly SpreadsheetContextItem<string, unknown>[];
+    columns: {
+        static: readonly unknown[];
+        dynamic: (params: {
+            dynamic: SpreadsheetDynamicBuilder<any>;
+            context: any;
+        }) => readonly unknown[];
+    };
+    references: any[];
+    resolutions: readonly 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>[];
+    relations: readonly unknown[];
+    buildRow: unknown;
+};
+export type { NormalizeSpreadsheetSchema };

package/dist/runtime/spreadsheet/schema/normalize.js

@@ -0,0 +1,127 @@
+import {
+  resolveSpreadsheetColumns,
+  resolveSpreadsheetReferences,
+  createSpreadsheetDynamicBuilder
+} from "../utils/builders/index.js";
+function isSpreadsheetColumnGroupDefinition(value) {
+  return value !== null && typeof value === "object" && "kind" in value && value.kind === "group" && "columns" in value;
+}
+function isSpreadsheetResolvableColumnDefinition(value) {
+  return value !== null && typeof value === "object" && "kind" in value && value.kind !== "group" && "key" in value && "resolve" in value && Boolean(value.resolve);
+}
+function isSpreadsheetReferenceDefinition(value) {
+  return value !== null && typeof value === "object" && "kind" in value && value.kind === "select" && "field" in value && "source" in value;
+}
+function collectSpreadsheetResolutionColumns(entries) {
+  const resolvedColumns = [];
+  for (const entry of entries) {
+    if (isSpreadsheetColumnGroupDefinition(entry)) {
+      resolvedColumns.push(...collectSpreadsheetResolutionColumns(entry.columns));
+      continue;
+    }
+    if (isSpreadsheetResolvableColumnDefinition(entry)) resolvedColumns.push(entry);
+  }
+  return resolvedColumns;
+}
+function normalizeSpreadsheetResolutionDefinitions(params) {
+  const columnResolutions = collectSpreadsheetResolutionColumns(
+    params.columns
+  ).flatMap((column) => {
+    if (!column.resolve) return [];
+    return [
+      {
+        kind: "select",
+        scope: "column",
+        targetField: column.key,
+        sourceField: column.key,
+        options: column.resolve.options,
+        getOptions: column.resolve.getOptions,
+        rules: column.rules
+      }
+    ];
+  });
+  const referenceResolutions = [];
+  for (const entry of params.references) {
+    if (!isSpreadsheetReferenceDefinition(entry)) continue;
+    referenceResolutions.push({
+      kind: "select",
+      scope: "reference",
+      targetField: entry.field,
+      sourceField: entry.source,
+      options: entry.options,
+      getOptions: entry.getOptions,
+      rules: entry.rules
+    });
+  }
+  return [...columnResolutions, ...referenceResolutions];
+}
+export function resolveSpreadsheetDynamicColumns(columns, context) {
+  if (!columns?.dynamic) return [];
+  return columns.dynamic({
+    context,
+    dynamic: createSpreadsheetDynamicBuilder(context)
+  });
+}
+export function resolveSpreadsheetBuildRow(buildRow) {
+  return buildRow;
+}
+export function normalizeSpreadsheetSchema(schema) {
+  const resolvedColumns = resolveSpreadsheetColumns(schema.columns);
+  const resolvedReferences = resolveSpreadsheetReferences(schema.references);
+  const staticColumns = resolvedColumns?.static ?? [];
+  const references = Array.isArray(resolvedReferences) ? resolvedReferences : [];
+  const steps = normalizeSpreadsheetSteps(schema);
+  return {
+    ...schema,
+    sheet: steps.structure?.sheet,
+    header: steps.structure?.header,
+    matching: steps.matching,
+    review: steps.review,
+    steps,
+    context: schema.context ?? [],
+    columns: {
+      static: staticColumns,
+      dynamic: resolvedColumns?.dynamic ?? (() => [])
+    },
+    references,
+    resolutions: normalizeSpreadsheetResolutionDefinitions({
+      columns: staticColumns,
+      references
+    }),
+    relations: schema.relations ?? [],
+    buildRow: resolveSpreadsheetBuildRow(schema.buildRow)
+  };
+}
+function normalizeSpreadsheetSteps(schema) {
+  const steps = toRecord(schema.steps);
+  const structure = toRecord(steps.structure);
+  return {
+    upload: toRecord(steps.upload),
+    structure: {
+      ...structure,
+      sheet: {
+        ...toRecord(schema.sheet),
+        ...toRecord(structure.sheet)
+      },
+      header: {
+        ...toRecord(schema.header),
+        ...toRecord(structure.header)
+      }
+    },
+    matching: {
+      ...toRecord(schema.matching),
+      ...toRecord(steps.matching)
+    },
+    references: toRecord(steps.references),
+    review: {
+      ...toRecord(schema.review),
+      ...toRecord(steps.review)
+    }
+  };
+}
+function toRecord(value) {
+  return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}