@shwfed/config 1.0.0

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

@@ -0,0 +1,258 @@
+import { Schema } from "effect";
+import { Expression } from "../../share/expression.js";
+import { Locale } from "../../share/locale.js";
+import { ActionSchemaFields } from "../actions/schema.js";
+import { FormConfig } from "../form/schema.js";
+import { allColumnSchemas } from "./utils/resolve.js";
+import { registerRowVariablesIfAbsent } from "./utils/shared.js";
+export { getStructFieldTitle, getStructFieldDescription } from "./utils/schema-meta.js";
+const KIND = "shwfed.component.table";
+const SortItem = Schema.Struct({
+  id: Schema.String.annotations({ description: "\u5217 ID" }),
+  desc: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+    description: "\u662F\u5426\u964D\u5E8F"
+  })
+}).annotations({ title: "SortItem", description: "\u6392\u5E8F\u89C4\u5219" });
+const ColumnPinning = Schema.Struct({
+  left: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u56FA\u5B9A\u5728\u5DE6\u4FA7\u7684\u5217 ID \u5217\u8868"
+  }),
+  right: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u56FA\u5B9A\u5728\u53F3\u4FA7\u7684\u5217 ID \u5217\u8868"
+  })
+}).annotations({ title: "ColumnPinning", description: "\u5217\u56FA\u5B9A\u914D\u7F6E" });
+const RowPinning = Schema.Struct({
+  top: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u56FA\u5B9A\u5728\u9876\u90E8\u7684\u884C ID \u5217\u8868"
+  }),
+  bottom: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u56FA\u5B9A\u5728\u5E95\u90E8\u7684\u884C ID \u5217\u8868"
+  })
+}).annotations({ title: "RowPinning", description: "\u884C\u56FA\u5B9A\u914D\u7F6E" });
+const InitialState = Schema.Struct({
+  columnVisibility: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Boolean })).annotations({
+    description: "\u5217\u53EF\u89C1\u6027\u6620\u5C04\uFF0C\u952E\u4E3A\u5217 ID\uFF0C\u503C\u4E3A\u662F\u5426\u53EF\u89C1"
+  }),
+  columnOrder: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u5217\u987A\u5E8F\uFF0C\u5217 ID \u6570\u7EC4"
+  }),
+  columnPinning: Schema.optional(ColumnPinning),
+  rowPinning: Schema.optional(RowPinning),
+  sorting: Schema.optional(Schema.Array(SortItem)).annotations({
+    description: "\u521D\u59CB\u6392\u5E8F\u72B6\u6001"
+  }),
+  expanded: Schema.optional(Schema.Union(
+    Schema.Boolean,
+    Schema.Record({ key: Schema.String, value: Schema.Boolean })
+  )).annotations({
+    description: "\u521D\u59CB\u5C55\u5F00\u72B6\u6001\uFF0Ctrue \u8868\u793A\u5168\u90E8\u5C55\u5F00\uFF0C\u6216\u6309\u884C ID \u6620\u5C04"
+  }),
+  grouping: Schema.optional(Schema.Array(Schema.String)).annotations({
+    description: "\u5206\u7EC4\u5217 ID \u5217\u8868"
+  }),
+  columnSizing: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Number })).annotations({
+    description: "\u5217\u5BBD\u6620\u5C04\uFF0C\u952E\u4E3A\u5217 ID\uFF0C\u503C\u4E3A\u50CF\u7D20\u5BBD\u5EA6"
+  }),
+  rowSelection: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Boolean })).annotations({
+    description: "\u521D\u59CB\u884C\u9009\u4E2D\u72B6\u6001\u6620\u5C04"
+  })
+}).annotations({
+  title: "InitialState",
+  description: "\u8868\u683C\u521D\u59CB\u72B6\u6001"
+});
+export const Pagination = Schema.Struct({
+  pageSizes: Schema.optionalWith(
+    Schema.Array(Schema.Number.pipe(Schema.int(), Schema.positive())),
+    { default: () => [100, 200, 500, 1e3] }
+  ).annotations({
+    title: "\u53EF\u9009\u5206\u9875\u5927\u5C0F",
+    description: "\u53EF\u9009\u5206\u9875\u5927\u5C0F\u5217\u8868"
+  }),
+  pageIndex: Schema.optionalWith(
+    Schema.Number.pipe(Schema.int(), Schema.nonNegative()),
+    { default: () => 0 }
+  ).annotations({
+    description: "\u521D\u59CB\u9875\u7801\uFF08\u4ECE 0 \u5F00\u59CB\uFF09"
+  }),
+  pageSize: Schema.optionalWith(
+    Schema.Number.pipe(Schema.int(), Schema.positive()),
+    { default: () => 20 }
+  ).annotations({
+    title: "\u521D\u59CB\u6BCF\u9875\u884C\u6570",
+    description: "\u521D\u59CB\u6BCF\u9875\u884C\u6570"
+  }),
+  left: Schema.optional(Locale).annotations({
+    title: "\u5206\u9875\u680F\u5DE6\u4FA7",
+    description: "\u5206\u9875\u680F\u5DE6\u4FA7\u672C\u5730\u5316 Markdown \u5185\u5BB9"
+  }),
+  right: Schema.optional(Locale).annotations({
+    title: "\u5206\u9875\u680F\u53F3\u4FA7",
+    description: "\u5206\u9875\u680F\u53F3\u4FA7\u672C\u5730\u5316 Markdown \u5185\u5BB9"
+  })
+}).annotations({
+  title: "Pagination",
+  description: "\u5206\u9875\u914D\u7F6E"
+});
+export const ColumnGroup = Schema.Struct({
+  id: Schema.UUID.annotations({ description: "\u5217\u5206\u7EC4\u552F\u4E00\u6807\u8BC6" }),
+  title: Schema.optional(Locale).annotations({
+    title: "\u5206\u7EC4\u6807\u9898",
+    description: "\u5217\u5206\u7EC4\u6807\u9898\u7684\u672C\u5730\u5316\u6587\u672C"
+  }),
+  tooltip: Schema.optional(Locale).annotations({
+    title: "\u5206\u7EC4\u63D0\u793A",
+    description: "\u5217\u5206\u7EC4\u63D0\u793A\u7684\u672C\u5730\u5316\u6587\u672C"
+  })
+}).annotations({
+  title: "ColumnGroup",
+  description: "\u5217\u5206\u7EC4\u5B9A\u4E49"
+});
+const QUERY_VAR_DESCRIPTION = "\u641C\u7D22\u6761\u4EF6\u5F53\u524D\u72B6\u6001\uFF1B\u672A\u914D\u7F6E\u641C\u7D22\u6761\u4EF6\u65F6\u4E3A\u7A7A\u5BF9\u8C61";
+export function DataSource(configure) {
+  const CelRequest = Expression({
+    configure: (env) => {
+      configure(env);
+      env.registerVariable("pageIndex", "number", { description: "\u5F53\u524D\u9875\u7801\uFF08\u4ECE 0 \u5F00\u59CB\uFF09\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
+      env.registerVariable("pageSize", "number", { description: "\u6BCF\u9875\u884C\u6570\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
+      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+    },
+    resultType: "HttpRequest"
+  });
+  const CelRows = Expression({
+    configure: (env) => {
+      configure(env);
+      env.registerVariable("json", "optional<dyn>", {
+        description: "HTTP \u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u914D\u7F6E request \u65F6\u4E3A none"
+      });
+      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+    },
+    resultType: (type) => type.startsWith("list") || type === "dyn" || type.startsWith("optional")
+  });
+  const CelTotal = Expression({
+    configure: (env) => {
+      configure(env);
+      env.registerVariable("json", "optional<dyn>", {
+        description: "HTTP \u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u914D\u7F6E request \u65F6\u4E3A none"
+      });
+      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+    },
+    resultType: (type) => type === "number" || type === "dyn" || type.startsWith("optional")
+  });
+  return Schema.Struct({
+    request: Schema.optional(CelRequest).annotations({
+      title: "\u8BF7\u6C42",
+      description: "\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\u8868\u8FBE\u5F0F\uFF1B\u672A\u914D\u7F6E\u65F6\u6570\u636E\u4ECE `data` \u8868\u8FBE\u5F0F\u4E2D\u8BFB\u53D6\uFF08\u901A\u5E38\u5F15\u7528\u4E0A\u4E0B\u6587\u53D8\u91CF\uFF09"
+    }),
+    data: CelRows.annotations({
+      title: "\u6570\u636E",
+      description: "\u8FD4\u56DE\u884C\u6570\u636E\u5217\u8868\uFF08`list<dyn>`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u5728\u914D\u7F6E\u4E86 `request` \u65F6\u53EF\u901A\u8FC7 `json` \u5F15\u7528\u54CD\u5E94\u4F53"
+    }),
+    total: Schema.optional(CelTotal).annotations({
+      title: "\u603B\u6570",
+      description: "\u8FD4\u56DE\u603B\u884C\u6570\uFF08`number`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u914D\u7F6E\u540E\u542F\u7528\u670D\u52A1\u7AEF\u5206\u9875\uFF0C\u7559\u7A7A\u5219\u8D70\u524D\u7AEF\u5206\u9875"
+    })
+  }).annotations({
+    title: "DataSource",
+    description: "\u6570\u636E\u6E90\u914D\u7F6E"
+  });
+}
+export function TableConfig(configure) {
+  const columnSchemas = allColumnSchemas(configure);
+  if (columnSchemas.length === 0) {
+    throw new Error("[shwfed-table] no columns registered under columns/<date>/<id>/");
+  }
+  const ColumnSchema = (columnSchemas.length === 1 ? columnSchemas[0] : Schema.Union(...columnSchemas)).annotations({
+    title: "Column",
+    description: "\u5217\u5B9A\u4E49\uFF0C\u7531 `type` \u5B57\u6BB5\u533A\u5206\u7C7B\u578B"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  const CelCellStyle = Expression({
+    configure: (env) => {
+      configure(env);
+      registerRowVariablesIfAbsent(env);
+      env.registerVariable("id", "string", { description: "\u5217 ID" });
+      env.registerVariable("selected", "bool", { description: "\u884C\u662F\u5426\u9009\u4E2D" });
+      env.registerVariable("pinned", "dyn", { description: "\u5217\u56FA\u5B9A\u72B6\u6001" });
+    },
+    resultType: (type) => type.startsWith("map")
+  });
+  const dataSourceSchema = DataSource(configure);
+  const { fields: actionFields } = ActionSchemaFields((env) => {
+    configure(env);
+    env.registerVariable("selected", "list<dyn>", {
+      description: "\u5F53\u524D\u5DF2\u52FE\u9009\u7684\u6240\u6709\u884C\uFF08`row` \u7684\u6570\u7EC4\uFF09"
+    });
+  });
+  const TableActions = Schema.Struct(actionFields).annotations({
+    title: "TableActions",
+    description: "\u8868\u683C\u7EA7\u64CD\u4F5C\u6309\u94AE"
+  });
+  const Query = FormConfig(configure);
+  return Schema.Struct({
+    kind: Schema.tag(KIND),
+    columns: Schema.Array(ColumnSchema).annotations({
+      description: "\u5217\u5B9A\u4E49\u5217\u8868"
+    }),
+    groups: Schema.optionalWith(Schema.Array(ColumnGroup), { default: () => [] }).annotations({
+      title: "\u5217\u5206\u7EC4",
+      description: "\u5217\u5206\u7EC4\u5217\u8868"
+    }),
+    dataSource: dataSourceSchema.annotations({
+      title: "\u6570\u636E\u6E90",
+      description: "\u6570\u636E\u6E90\u914D\u7F6E"
+    }),
+    actions: Schema.optional(TableActions).annotations({
+      title: "\u64CD\u4F5C",
+      description: "\u8868\u683C\u9876\u90E8\u64CD\u4F5C\u6309\u94AE"
+    }),
+    query: Schema.optional(Query).annotations({
+      title: "\u641C\u7D22\u6761\u4EF6",
+      description: "\u6E32\u67D3\u5728\u8868\u683C\u4E0A\u65B9\u7684\u641C\u7D22\u6761\u4EF6\u8868\u5355\uFF1B\u5176\u5F53\u524D\u503C\u4EE5 `query` \u53D8\u91CF\u6CE8\u5165\u6570\u636E\u6E90\u8868\u8FBE\u5F0F"
+    }),
+    cellStyle: Schema.optional(CelCellStyle).annotations({
+      title: "\u5355\u5143\u683C\u6837\u5F0F",
+      description: "\u5355\u5143\u683C\u6837\u5F0F CEL \u8868\u8FBE\u5F0F"
+    }),
+    style: Schema.optional(Schema.String).annotations({
+      title: "\u5BB9\u5668\u6837\u5F0F",
+      description: "\u5E94\u7528\u5728\u8868\u683C\u6700\u5916\u5C42\u5BB9\u5668\u4E0A\u7684 CSS \u6837\u5F0F\u5B57\u7B26\u4E32"
+    }),
+    pagination: Schema.optional(Pagination).annotations({
+      title: "\u5206\u9875"
+    }),
+    initialState: Schema.optional(InitialState)
+  }).pipe(Schema.filter((cfg) => {
+    if (cfg.dataSource?.total !== void 0 && cfg.pagination === void 0) {
+      return "\u914D\u7F6E\u4E86 dataSource.total \u65F6\u5FC5\u987B\u540C\u65F6\u914D\u7F6E\u5206\u9875\uFF08\u81F3\u5C11\u586B\u5199\u6BCF\u9875\u884C\u6570\u6216\u53EF\u9009\u5206\u9875\u5927\u5C0F\uFF09";
+    }
+    return true;
+  })).annotations({
+    title: "TableConfig",
+    description: "\u8868\u683C\u7EC4\u4EF6\u5B8C\u6574\u914D\u7F6E"
+  });
+}
+export function createTableConfig(body) {
+  return {
+    kind: KIND,
+    ...body
+  };
+}
+export function defaultTableConfig() {
+  return {
+    kind: KIND,
+    columns: [],
+    groups: [],
+    dataSource: { data: "[]" },
+    pagination: {
+      pageSizes: [100, 200, 500, 1e3],
+      pageIndex: 0,
+      pageSize: 100
+    },
+    cellStyle: `selected
+  ? { 'background-color': 'color-mix(in srgb, var(--primary) 10%, white) !important' }
+  : index % 2 == 1 ? { 'background-color': 'oklch(98.5% 0 0)' } : { 'background-color': 'white' }`
+  };
+}
+export function getColumnTechnicalKey(column) {
+  return column.id;
+}

package/dist/runtime/components/table/utils/host.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey } from 'vue';
+export type TableHost = Readonly<{
+    search: () => Promise<void>;
+    refetch: () => Promise<void>;
+    resetQuery: () => Promise<void>;
+}>;
+export declare const TABLE_HOST_KEY: InjectionKey<TableHost>;
+export declare function provideTableHost(host: TableHost): void;
+export declare function useTableHost(): TableHost | undefined;

package/dist/runtime/components/table/utils/host.js

@@ -0,0 +1,8 @@
+import { inject, provide } from "vue";
+export const TABLE_HOST_KEY = Symbol("shwfed-table-host");
+export function provideTableHost(host) {
+  provide(TABLE_HOST_KEY, host);
+}
+export function useTableHost() {
+  return inject(TABLE_HOST_KEY, void 0);
+}

package/dist/runtime/components/table/utils/resolve.d.ts

@@ -0,0 +1,32 @@
+import type { Component } from 'vue';
+import type { Schema, Effect } from 'effect';
+import type { ColumnDef } from '@tanstack/vue-table';
+import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+import type { LocaleValue } from '../../../share/locale.js';
+type CelEvaluator = <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, any>;
+type AnySchema = Schema.Schema<any, any, never>;
+type SchemaFactory = (configure: (env: Environment) => void) => AnySchema;
+export type ColumnMetadata = Readonly<{
+    name: string;
+    icon: string;
+}>;
+export type ColumnDefDeps = Readonly<{
+    getLocaleText: (value: LocaleValue | undefined) => string | undefined;
+    $cel: CelEvaluator;
+    inheritedContext: Record<string, unknown>;
+}>;
+type ToColumnDef = (value: any, deps: ColumnDefDeps) => Partial<ColumnDef<unknown, unknown>>;
+export type ColumnEntry = Readonly<{
+    type: string;
+    compatibilityDate: string;
+    metadata: ColumnMetadata;
+    schema: SchemaFactory;
+    config: Component;
+    runtime: Component;
+    toColumnDef: ToColumnDef;
+}>;
+export declare const COLUMNS: ReadonlyArray<ColumnEntry>;
+export declare function allColumnSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;
+export declare function findColumn(type: string, compatibilityDate: string): ColumnEntry | undefined;
+export declare function latestColumnByType(): ReadonlyArray<ColumnEntry>;
+export {};

package/dist/runtime/components/table/utils/resolve.js

@@ -0,0 +1,50 @@
+import { defineRegistry } from "../../../share/define-registry.js";
+const schemaModules = import.meta.glob(
+  "../columns/*/*/schema.ts",
+  { eager: true }
+);
+const configModules = import.meta.glob(
+  "../columns/*/*/config.vue",
+  { eager: true, import: "default" }
+);
+const runtimeModules = import.meta.glob(
+  "../columns/*/*/runtime.vue",
+  { eager: true, import: "default" }
+);
+const registry = defineRegistry({
+  hostName: "shwfed-table",
+  dirSegment: "columns",
+  schemaModules,
+  configModules,
+  runtimeModules,
+  validateModule: (mod, type, date) => {
+    if (typeof mod.toColumnDef !== "function") {
+      throw new TypeError(`[shwfed-table] column "${type}@${date}" is missing toColumnDef export`);
+    }
+  }
+});
+export const COLUMNS = registry.ENTRIES.map((e) => ({
+  type: e.type,
+  compatibilityDate: e.compatibilityDate,
+  metadata: e.module.metadata,
+  schema: e.module.schema,
+  config: e.config,
+  runtime: e.runtime,
+  toColumnDef: e.module.toColumnDef
+}));
+export function allColumnSchemas(configure) {
+  return COLUMNS.map((entry) => entry.schema(configure));
+}
+export function findColumn(type, compatibilityDate) {
+  return COLUMNS.find((r) => r.type === type && r.compatibilityDate === compatibilityDate);
+}
+export function latestColumnByType() {
+  const byType = /* @__PURE__ */ new Map();
+  for (const r of COLUMNS) {
+    const prev = byType.get(r.type);
+    if (!prev || r.compatibilityDate > prev.compatibilityDate) {
+      byType.set(r.type, r);
+    }
+  }
+  return [...byType.values()];
+}

package/dist/runtime/components/table/utils/runtime.d.ts

@@ -0,0 +1,6 @@
+import type { Effect as EffectType } from 'effect';
+export declare const JUSTIFY_CLASS: Record<string, string>;
+type CelEvaluator = <T>(expression: string, context?: Record<string, unknown>) => EffectType.Effect<T, any>;
+export declare function interpolateMarkdown(template: string, $cel: CelEvaluator, context: Record<string, unknown>): string;
+export declare function evaluateMarkdown(template: string, $cel: CelEvaluator, context: Record<string, unknown>): string;
+export {};

package/dist/runtime/components/table/utils/runtime.js

@@ -0,0 +1,28 @@
+import { Effect } from "effect";
+import { renderMarkdown } from "../../../utils/markdown.js";
+export const JUSTIFY_CLASS = {
+  left: "justify-start",
+  center: "justify-center",
+  right: "justify-end"
+};
+const INTERPOLATION_RE = /\{\{(.*?)\}\}/gs;
+function stringifyCelResult(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+export function interpolateMarkdown(template, $cel, context) {
+  return template.replace(INTERPOLATION_RE, (_, expr) => {
+    const trimmed = expr.trim();
+    if (!trimmed) return "";
+    try {
+      return stringifyCelResult(Effect.runSync($cel(trimmed, context)));
+    } catch (e) {
+      console.error("[shwfed-table] markdown interpolation failed", e);
+      return "";
+    }
+  });
+}
+export function evaluateMarkdown(template, $cel, context) {
+  return renderMarkdown(interpolateMarkdown(template, $cel, context));
+}

package/dist/runtime/components/table/utils/schema-meta.d.ts

@@ -0,0 +1,5 @@
+import { type Schema } from 'effect';
+type AnySchema = Schema.Schema<any, any, any>;
+export declare function getStructFieldTitle(schema: AnySchema, fieldName: string): string | undefined;
+export declare function getStructFieldDescription(schema: AnySchema, fieldName: string): string | undefined;
+export {};

package/dist/runtime/components/table/utils/schema-meta.js

@@ -0,0 +1,48 @@
+import { Option, SchemaAST } from "effect";
+function getTypeLiteral(ast) {
+  switch (ast._tag) {
+    case "TypeLiteral":
+      return ast;
+    case "Transformation":
+      return getTypeLiteral(ast.to);
+    case "Refinement":
+      return getTypeLiteral(ast.from);
+    case "Suspend":
+      return getTypeLiteral(ast.f());
+    default:
+      return null;
+  }
+}
+function findPropertySignature(schema, fieldName) {
+  const tl = getTypeLiteral(schema.ast);
+  if (!tl) return null;
+  return tl.propertySignatures.find((p) => p.name === fieldName) ?? null;
+}
+function resolveFieldType(ps) {
+  const t = ps.type;
+  if (t._tag === "Union" && ps.isOptional) {
+    const nonUndef = t.types.find((m) => m._tag !== "UndefinedKeyword");
+    if (nonUndef) return nonUndef;
+  }
+  return t;
+}
+function getFieldAnnotation(schema, fieldName, getter) {
+  const ps = findPropertySignature(schema, fieldName);
+  if (!ps) return void 0;
+  const fromPS = getter(ps);
+  if (Option.isSome(fromPS)) return fromPS.value;
+  const resolved = resolveFieldType(ps);
+  const fromResolved = getter(resolved);
+  if (Option.isSome(fromResolved)) return fromResolved.value;
+  if (resolved !== ps.type) {
+    const fromType = getter(ps.type);
+    if (Option.isSome(fromType)) return fromType.value;
+  }
+  return void 0;
+}
+export function getStructFieldTitle(schema, fieldName) {
+  return getFieldAnnotation(schema, fieldName, SchemaAST.getTitleAnnotation);
+}
+export function getStructFieldDescription(schema, fieldName) {
+  return getFieldAnnotation(schema, fieldName, SchemaAST.getDescriptionAnnotation);
+}

package/dist/runtime/components/table/utils/shared.d.ts

@@ -0,0 +1,40 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+export declare const Align: Schema.Literal<["left", "center", "right"]>;
+export declare function columnIdentityFields(): {
+    id: Schema.refine<string, typeof Schema.String>;
+    groupId: Schema.optional<typeof Schema.UUID>;
+};
+export declare function columnFields(configure: (env: Environment) => void): {
+    title: Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>;
+    accessor: Schema.Schema<string, string, never>;
+    enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    id: Schema.refine<string, typeof Schema.String>;
+    groupId: Schema.optional<typeof Schema.UUID>;
+};
+export declare function registerRowVariablesIfAbsent(env: Environment): void;
+export declare function CelRowAccess(configure: (env: Environment) => void, options?: {
+    resultType?: string | string[];
+}): Schema.Schema<string, string, never>;
+export declare function LocaleMarkdownWithRow(configure: (env: Environment) => void): Schema.filter<Schema.TupleType<readonly [Schema.Struct<{
+    locale: Schema.Literal<["zh"]>;
+    message: Schema.SchemaClass<string, string, never>;
+}>], [Schema.Struct<{
+    locale: Schema.Literal<["ja", "en", "ko"]>;
+    message: Schema.SchemaClass<string, string, never>;
+}>]>>;

package/dist/runtime/components/table/utils/shared.js

@@ -0,0 +1,67 @@
+import { Schema } from "effect";
+import { Expression, LocaleMarkdown } from "../../../share/expression.js";
+import { Locale } from "../../../share/locale.js";
+import { md } from "../../../share/markdown.js";
+export const Align = Schema.Literal("left", "center", "right").annotations({
+  description: "\u5BF9\u9F50\u65B9\u5F0F"
+});
+export function columnIdentityFields() {
+  return {
+    id: Schema.UUID.annotations({ description: "\u5217\u552F\u4E00\u6807\u8BC6" }),
+    groupId: Schema.optional(Schema.UUID).annotations({
+      description: "\u6240\u5C5E\u5217\u5206\u7EC4\u6807\u8BC6\uFF0C\u672A\u8BBE\u7F6E\u65F6\u4E3A\u9876\u5C42\u5217"
+    })
+  };
+}
+export function columnFields(configure) {
+  return {
+    ...columnIdentityFields(),
+    title: Locale.annotations({ title: "\u540D\u79F0", description: "\u5217\u6807\u9898" }),
+    accessor: CelRowAccess(configure).annotations({
+      title: "\u8DEF\u5F84",
+      description: "\u884C\u6570\u636E\u8BBF\u95EE CEL \u8868\u8FBE\u5F0F\uFF0C\u4F8B\u5982 `row.user.name`"
+    }),
+    enableSorting: Schema.optional(Schema.Boolean.annotations({
+      title: "\u5141\u8BB8\u6392\u5E8F",
+      description: md`
+        显示排序按钮：
+
+        排序分为两类：**服务端排序** 和 **客户端排序**。
+
+        | | 服务端排序 | 客户端排序 |
+        | --- | --- | --- |
+        | 数据量 | **全量**，能够跨越多页 | 当前页 |
+        | 开发量 | 需要后端支持，可能影响性能 | **配置即启用，无需后端支持** |
+
+        注意：对于服务端排序，除了在这里打开排序开关，你还需要在「通用配置 → 数据源 → 请求」处，**将正在排序字段、排序状态传给后端**。
+      `
+    })),
+    size: Schema.optional(Schema.Number.pipe(Schema.finite(), Schema.positive()).annotations({
+      title: "\u5217\u5BBD",
+      description: "\u6307\u5B9A\u4E00\u4E2A\u5408\u9002\u7684\u8868\u683C\u5217\u5BBD\u5EA6\uFF0C\u5F53\u5217\u5185\u5BB9\u957F\u5EA6\u5927\u4E8E\u8FD9\u91CC\u6307\u5B9A\u7684\u5BBD\u5EA6\u540E\uFF0C\u4F1A\u5BFC\u81F4\u8D85\u51FA\u7684\u90E8\u5206\u88AB\u622A\u65AD\u3002"
+    })),
+    grow: Schema.optional(Schema.Boolean.annotations({ title: "\u5360\u636E\u5269\u4F59\u5BBD\u5EA6", description: "\u5217\u662F\u5426\u5360\u636E\u5269\u4F59\u7A7A\u4F59\u5BBD\u5EA6" })),
+    tooltip: Schema.optional(Locale.annotations({ title: "\u63D0\u793A", description: "\u5217\u6807\u9898\u60AC\u6D6E\u63D0\u793A\uFF0C\u652F\u6301 Markdown" }))
+  };
+}
+export function registerRowVariablesIfAbsent(env) {
+  const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+  if (!declared.has("row")) {
+    env.registerVariable("row", "dyn", { description: "\u5F53\u524D\u884C\u6570\u636E" });
+  }
+  if (!declared.has("index")) {
+    env.registerVariable("index", "number", { description: "\u884C\u7D22\u5F15" });
+  }
+}
+function configureWithRow(configure) {
+  return (env) => {
+    configure(env);
+    registerRowVariablesIfAbsent(env);
+  };
+}
+export function CelRowAccess(configure, options) {
+  return Expression({ configure: configureWithRow(configure), resultType: options?.resultType });
+}
+export function LocaleMarkdownWithRow(configure) {
+  return LocaleMarkdown({ configure: configureWithRow(configure) });
+}

package/dist/runtime/components/ui/alert-dialog/AlertDialog.d.vue.ts

@@ -0,0 +1,21 @@
+import type { AlertDialogProps } from 'reka-ui';
+declare var __VLS_8: {
+    open: boolean;
+    close: () => void;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<AlertDialogProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<AlertDialogProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialog.vue

@@ -0,0 +1,20 @@
+<script setup>
+import { AlertDialogRoot, useForwardPropsEmits } from "reka-ui";
+defineOptions({ name: "AlertDialogRoot" });
+const props = defineProps({
+  open: { type: Boolean, required: false },
+  defaultOpen: { type: Boolean, required: false }
+});
+const emits = defineEmits(["update:open"]);
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <AlertDialogRoot
+    v-slot="slotProps"
+    data-slot="alert-dialog"
+    v-bind="forwarded"
+  >
+    <slot v-bind="slotProps" />
+  </AlertDialogRoot>
+</template>

package/dist/runtime/components/ui/alert-dialog/AlertDialog.vue.d.ts

@@ -0,0 +1,21 @@
+import type { AlertDialogProps } from 'reka-ui';
+declare var __VLS_8: {
+    open: boolean;
+    close: () => void;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<AlertDialogProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<AlertDialogProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialogAction.d.vue.ts

@@ -0,0 +1,18 @@
+import type { AlertDialogActionProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = AlertDialogActionProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};