@shwfed/nuxt 0.7.8 → 0.7.10

package/dist/runtime/components/ui/table/Table.vue.d.ts

@@ -0,0 +1,81 @@
+import { type CellContext, type TableOptions } from '@tanstack/vue-table';
+import { Effect } from 'effect';
+import { type TableConfig } from './schema.js';
+export type { Accessor, Column, Expression, Markdown, Render, TableConfig } from './schema.js';
+export { AccessorC, ColumnC, RenderC, TableConfigC } from './schema.js';
+declare module '@tanstack/vue-table' {
+    interface ColumnMeta<TData extends import('@tanstack/vue-table').RowData, TValue> {
+        tooltip?: string;
+        grow?: boolean;
+        accessor?: import('./schema').Accessor;
+        __types?: [TData, TValue];
+    }
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    config: Effect.Effect<TableConfig>;
+    data: Array<unknown>;
+    rowCount?: number;
+}, import("@tanstack/table-core").Table<unknown>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:config": (args_0: Readonly<{
+        getRowId?: import("./schema.js").Expression;
+        getSubRows?: import("./schema.js").Expression;
+        enableRowSelection?: import("./schema.js").Expression;
+        enableMultiRowSelection?: import("./schema.js").Expression;
+        columns: readonly Readonly<{
+            id?: string;
+            title?: import("../../../utils/coders.js").LocaleValue;
+            accessor?: import("./schema.js").Accessor;
+            renderer?: import("./schema.js").Render;
+            tooltip?: import("../../../utils/coders.js").LocaleValue;
+            size?: number;
+            enableSorting?: boolean;
+            enableMultiSorting?: boolean;
+            enablePinning?: boolean;
+            columns?: readonly Readonly</*elided*/ any>[];
+            grow?: boolean;
+        }>[];
+        cellStyles?: import("./schema.js").Expression;
+        props?: Omit<TableOptions<unknown>, "columns" | "data" | "getRowId" | "getCoreRowModel">;
+        paginationLeft?: import("./schema.js").Markdown;
+        paginationRight?: import("./schema.js").Markdown;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    config: Effect.Effect<TableConfig>;
+    data: Array<unknown>;
+    rowCount?: number;
+}> & Readonly<{
+    "onUpdate:config"?: ((args_0: Readonly<{
+        getRowId?: import("./schema.js").Expression;
+        getSubRows?: import("./schema.js").Expression;
+        enableRowSelection?: import("./schema.js").Expression;
+        enableMultiRowSelection?: import("./schema.js").Expression;
+        columns: readonly Readonly<{
+            id?: string;
+            title?: import("../../../utils/coders.js").LocaleValue;
+            accessor?: import("./schema.js").Accessor;
+            renderer?: import("./schema.js").Render;
+            tooltip?: import("../../../utils/coders.js").LocaleValue;
+            size?: number;
+            enableSorting?: boolean;
+            enableMultiSorting?: boolean;
+            enablePinning?: boolean;
+            columns?: readonly Readonly</*elided*/ any>[];
+            grow?: boolean;
+        }>[];
+        cellStyles?: import("./schema.js").Expression;
+        props?: Omit<TableOptions<unknown>, "columns" | "data" | "getRowId" | "getCoreRowModel">;
+        paginationLeft?: import("./schema.js").Markdown;
+        paginationRight?: import("./schema.js").Markdown;
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    [key: string]: (props: Readonly<{
+        cell: CellContext<unknown, unknown>;
+    }>) => void;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/table/schema.d.ts

@@ -0,0 +1,48 @@
+import type { TableOptions } from '@tanstack/vue-table';
+import z from 'zod';
+import type { LocaleValue } from '../../../utils/coders.js';
+export type Expression = string;
+export type Markdown = string;
+export type Render = string | Readonly<{
+    id: string;
+    props: unknown;
+}>;
+export type Accessor = string | Readonly<{
+    read: Expression;
+    write: Expression;
+}>;
+export type Column = Readonly<{
+    id?: string;
+    title?: LocaleValue;
+    accessor?: Accessor;
+    renderer?: Render;
+    tooltip?: LocaleValue;
+    size?: number;
+    enableSorting?: boolean;
+    enableMultiSorting?: boolean;
+    enablePinning?: boolean;
+    columns?: ReadonlyArray<Column>;
+    grow?: boolean;
+}>;
+export declare const RenderC: z.ZodType<Render>;
+export declare const AccessorC: z.ZodType<Accessor>;
+export declare const ColumnC: z.ZodType<Column>;
+export type TableConfig = Readonly<{
+    getRowId?: Expression;
+    getSubRows?: Expression;
+    enableRowSelection?: Expression;
+    enableMultiRowSelection?: Expression;
+    columns: ReadonlyArray<Column>;
+    cellStyles?: Expression;
+    props?: Omit<TableOptions<unknown>, 'columns' | 'data' | 'getRowId' | 'getCoreRowModel'>;
+    paginationLeft?: Markdown;
+    paginationRight?: Markdown;
+}>;
+export declare const TableConfigGetRowIdC: z.ZodOptional<z.ZodString>;
+export declare const TableConfigGetSubRowsC: z.ZodOptional<z.ZodString>;
+export declare const TableConfigEnableRowSelectionC: z.ZodOptional<z.ZodString>;
+export declare const TableConfigEnableMultiRowSelectionC: z.ZodOptional<z.ZodString>;
+export declare const TableConfigCellStylesC: z.ZodOptional<z.ZodString>;
+export declare const TableConfigC: z.ZodType<TableConfig>;
+export declare function getLocalizedText(messages: LocaleValue | undefined, locale: string): string | undefined;
+export declare function getColumnTechnicalKey(column: Column): string | undefined;

package/dist/runtime/components/ui/table/schema.js

@@ -0,0 +1,126 @@
+import z from "zod";
+import { dotPropC, expressionC, localeC } from "../../../utils/coders.js";
+export const RenderC = z.union([
+  z.string(),
+  z.object({
+    id: z.string(),
+    props: z.unknown()
+  }).readonly()
+]);
+export const AccessorC = z.union([
+  dotPropC,
+  z.object({
+    read: expressionC(/.+/, { row: "dyn", index: "int" }),
+    write: z.string()
+  }).readonly()
+]);
+export const ColumnC = z.object({
+  id: z.string().optional(),
+  title: localeC.optional(),
+  accessor: AccessorC.optional(),
+  renderer: RenderC.optional(),
+  tooltip: localeC.optional(),
+  size: z.number().optional(),
+  enableSorting: z.boolean().optional(),
+  enableMultiSorting: z.boolean().optional(),
+  enablePinning: z.boolean().optional(),
+  columns: z.lazy(() => z.array(ColumnC).readonly()).optional(),
+  grow: z.boolean().optional()
+}).strict().readonly();
+const InitialTableStateC = z.object({
+  columnVisibility: z.record(z.string(), z.boolean()).optional(),
+  columnOrder: z.array(z.string()).readonly().optional(),
+  columnPinning: z.object({
+    left: z.array(z.string()).readonly().optional(),
+    right: z.array(z.string()).readonly().optional()
+  }).readonly().optional(),
+  rowPinning: z.object({
+    top: z.array(z.string()).readonly().optional(),
+    bottom: z.array(z.string()).readonly().optional()
+  }).readonly().optional(),
+  columnFilters: z.array(z.object({
+    id: z.string(),
+    value: z.unknown()
+  }).readonly()).readonly().optional(),
+  globalFilter: z.unknown().optional(),
+  sorting: z.array(z.object({
+    id: z.string(),
+    desc: z.boolean()
+  }).readonly()).readonly().optional(),
+  expanded: z.union([
+    z.boolean(),
+    z.record(z.string(), z.boolean())
+  ]).optional(),
+  grouping: z.array(z.string()).readonly().optional(),
+  columnSizing: z.record(z.string(), z.number()).optional(),
+  columnSizingInfo: z.record(z.string(), z.unknown()).optional(),
+  pagination: z.object({
+    pageIndex: z.number().optional(),
+    pageSize: z.number().optional()
+  }).readonly().optional(),
+  rowSelection: z.record(z.string(), z.boolean()).optional()
+}).readonly();
+const TablePropsC = z.any().optional().superRefine((value, ctx) => {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "table props \u5FC5\u987B\u662F\u5BF9\u8C61"
+    });
+    return;
+  }
+  if (!Reflect.has(value, "initialState")) {
+    return;
+  }
+  const result = InitialTableStateC.safeParse(Reflect.get(value, "initialState"));
+  if (!result.success) {
+    ctx.addIssue({
+      code: "custom",
+      message: "\u65E0\u6548\u7684 props.initialState \u914D\u7F6E",
+      path: ["initialState"]
+    });
+  }
+});
+export const TableConfigGetRowIdC = expressionC("string", { row: "dyn", index: "int", parent: "dyn" }).optional();
+export const TableConfigGetSubRowsC = expressionC(/.+/, { row: "dyn", index: "int" }).optional();
+export const TableConfigEnableRowSelectionC = expressionC("bool", { row: "dyn", index: "int", id: "string" }).optional();
+export const TableConfigEnableMultiRowSelectionC = expressionC("bool", { row: "dyn", index: "int", id: "string" }).optional();
+export const TableConfigCellStylesC = expressionC(/^map/, {
+  row: "dyn",
+  index: "int",
+  id: "string",
+  selected: "bool",
+  pinned: "dyn"
+}).optional();
+export const TableConfigC = z.object({
+  getRowId: TableConfigGetRowIdC,
+  getSubRows: TableConfigGetSubRowsC,
+  enableRowSelection: TableConfigEnableRowSelectionC,
+  enableMultiRowSelection: TableConfigEnableMultiRowSelectionC,
+  columns: z.array(ColumnC).readonly(),
+  cellStyles: TableConfigCellStylesC,
+  props: TablePropsC,
+  paginationLeft: z.string().optional(),
+  paginationRight: z.string().optional()
+}).readonly();
+export function getLocalizedText(messages, locale) {
+  if (!messages) {
+    return void 0;
+  }
+  const localizedMessage = messages.find((message) => message.locale === locale && message.message.trim().length > 0);
+  if (localizedMessage) {
+    return localizedMessage.message;
+  }
+  return messages.find((message) => message.message.trim().length > 0)?.message;
+}
+export function getColumnTechnicalKey(column) {
+  if (typeof column.accessor === "string") {
+    return column.accessor;
+  }
+  if (column.id) {
+    return column.id;
+  }
+  return column.accessor?.read;
+}

package/dist/runtime/components/ui/table-configurator/TableConfiguratorDialog.d.vue.ts

@@ -0,0 +1,62 @@
+import { type LocaleValue } from '../../../utils/coders.js';
+import type { TableConfig } from '../table/schema.js';
+type __VLS_Props = {
+    config: TableConfig;
+};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    confirm: (args_0: Readonly<{
+        getRowId?: import("../table/schema.js").Expression;
+        getSubRows?: import("../table/schema.js").Expression;
+        enableRowSelection?: import("../table/schema.js").Expression;
+        enableMultiRowSelection?: import("../table/schema.js").Expression;
+        columns: readonly Readonly<{
+            id?: string;
+            title?: LocaleValue;
+            accessor?: import("../table/schema.js").Accessor;
+            renderer?: import("../table/schema.js").Render;
+            tooltip?: LocaleValue;
+            size?: number;
+            enableSorting?: boolean;
+            enableMultiSorting?: boolean;
+            enablePinning?: boolean;
+            columns?: readonly Readonly</*elided*/ any>[];
+            grow?: boolean;
+        }>[];
+        cellStyles?: import("../table/schema.js").Expression;
+        props?: Omit<import("@tanstack/table-core").TableOptions<unknown>, "columns" | "data" | "getRowId" | "getCoreRowModel">;
+        paginationLeft?: import("../table/schema.js").Markdown;
+        paginationRight?: import("../table/schema.js").Markdown;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onConfirm?: ((args_0: Readonly<{
+        getRowId?: import("../table/schema.js").Expression;
+        getSubRows?: import("../table/schema.js").Expression;
+        enableRowSelection?: import("../table/schema.js").Expression;
+        enableMultiRowSelection?: import("../table/schema.js").Expression;
+        columns: readonly Readonly<{
+            id?: string;
+            title?: LocaleValue;
+            accessor?: import("../table/schema.js").Accessor;
+            renderer?: import("../table/schema.js").Render;
+            tooltip?: LocaleValue;
+            size?: number;
+            enableSorting?: boolean;
+            enableMultiSorting?: boolean;
+            enablePinning?: boolean;
+            columns?: readonly Readonly</*elided*/ any>[];
+            grow?: boolean;
+        }>[];
+        cellStyles?: import("../table/schema.js").Expression;
+        props?: Omit<import("@tanstack/table-core").TableOptions<unknown>, "columns" | "data" | "getRowId" | "getCoreRowModel">;
+        paginationLeft?: import("../table/schema.js").Markdown;
+        paginationRight?: import("../table/schema.js").Markdown;
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;