@planet-matrix/mobius-model 0.6.0 → 0.9.0

package/src/drizzle/README.md

@@ -0,0 +1 @@
+# Drizzle

package/src/drizzle/drizzle.ts

@@ -0,0 +1 @@
+export * as d from "drizzle-orm"

package/src/drizzle/helper.ts

@@ -0,0 +1,47 @@
+import type { ExtractTablesWithRelations } from "drizzle-orm"
+import { PgDatabase, PgTransaction } from "drizzle-orm/pg-core"
+import type {
+  PostgresJsDatabase as RawPostgresJsDatabase,
+  PostgresJsTransaction as RawPostgresJsTransaction,
+} from "drizzle-orm/postgres-js"
+
+export type PostgresJsNormalDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = RawPostgresJsDatabase<Schema>
+export type PostgresJsTransactionDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = RawPostgresJsTransaction<Schema, ExtractTablesWithRelations<Schema>>
+export type PostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = PostgresJsNormalDatabase<Schema> | PostgresJsTransactionDatabase<Schema>
+export interface WithPostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>> {
+  database: PostgresJsDatabase<Schema>
+}
+export interface WithOptionalPostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>> {
+  database?: PostgresJsDatabase<Schema> | undefined
+}
+export type WithoutPostgresJsDatabase<T> = Omit<T, "database">
+
+export const isPostgresJsNormalDatabase = <Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+): database is PostgresJsNormalDatabase<Schema> => {
+  return database instanceof PgDatabase
+}
+export const isPostgresJsTransactionDatabase = <Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+): database is PostgresJsTransactionDatabase<Schema> => {
+  return database instanceof PgTransaction
+}
+export const autoPostgresJsDatabaseTransaction = async <Result, Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+  run: (database: PostgresJsTransactionDatabase<Schema>) => Promise<Result>,
+): Promise<Result> => {
+  // detect transaction database first, then normal database
+  // because transaction database is a subclass of normal database
+  if (isPostgresJsTransactionDatabase(database)) {
+    return await run(database)
+  }
+  if (isPostgresJsNormalDatabase(database)) {
+    return await database.transaction(async (database) => {
+      return await run(database)
+    })
+  }
+  throw new Error("Invalid database instance")
+}

package/src/drizzle/index.ts

@@ -0,0 +1,5 @@
+export * from "./drizzle.ts"
+export type * from "./infer.ts"
+export type * from "./kysely.ts"
+export * from "./pagination.ts"
+export * from "./helper.ts"

package/src/drizzle/infer.ts

@@ -0,0 +1,52 @@
+import type { DrizzleTypeError, InferEnum, InferInsertModel, InferSelectModel } from "drizzle-orm"
+import type { PgEnum, PgTableWithColumns } from "drizzle-orm/pg-core"
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js"
+
+type RemoveNeverValue<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K]
+}
+
+type PreInferModel<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? InferSelectModel<T[K]>
+  : (
+    T[K] extends PgEnum<infer __>
+    ? InferEnum<T[K]>
+    : never
+  )
+}
+export type InferModel<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferModel<T>>
+
+type PreInferInsert<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? InferInsertModel<T[K]>
+  : never
+}
+export type InferInsert<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferInsert<T>>
+
+type PreInferUpdate<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? Partial<InferSelectModel<T[K]>>
+  : (
+    T[K] extends PgEnum<infer __>
+    ? InferEnum<T[K]>
+    : never
+  )
+}
+export type InferUpdate<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferUpdate<T>>
+
+type GetValidQuery<T extends Record<string, unknown> = Record<string, never>> = Exclude<
+  PostgresJsDatabase<T>["query"],
+  DrizzleTypeError<string>
+>
+type PreInferWith<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof GetValidQuery<T>]: NonNullable<NonNullable<Parameters<GetValidQuery<T>[K]["findMany"]>[0]>["with"]>
+}
+export type InferWith<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferWith<T>>
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type AnyPgTableWithColumns = PgTableWithColumns<any>
+type PreInferModelFromPgTableWithColumns<T extends AnyPgTableWithColumns> = {
+  [K in keyof InferSelectModel<T>]: InferSelectModel<T>[K]
+}
+export type InferModelFromPgTableWithColumns<T extends AnyPgTableWithColumns> = RemoveNeverValue<PreInferModelFromPgTableWithColumns<T>>

package/src/drizzle/kysely.ts

@@ -0,0 +1,8 @@
+import type { Table } from "drizzle-orm"
+import type { Kyselify } from "drizzle-orm/kysely"
+import type { AnyPgTable } from "drizzle-orm/pg-core"
+
+export type KyselifyTable<T extends Table> = Kyselify<T>
+export type KyselifyDatabase<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T as T[K] extends AnyPgTable ? T[K]["_"]["name"] : never]: T[K] extends AnyPgTable ? Kyselify<T[K]> : never
+}

package/src/drizzle/pagination.ts

@@ -0,0 +1,200 @@
+import { d } from "./drizzle.ts"
+import type { AnyPgTableWithColumns, InferModelFromPgTableWithColumns } from "./infer.ts"
+
+export type Cursor = string | null
+export interface WithCursorBasedPaginationOptions {
+  limit: number
+  cursor: Cursor
+}
+export interface WithCursorBasedPaginationResult {
+  nextCursor: Cursor
+  totalCount: number
+}
+
+interface OrderByItem<Key> {
+  key: Key
+  order: "asc" | "desc"
+}
+export interface EncodeCursorOptions<Model> {
+  model: Model
+  orderBy: Array<OrderByItem<keyof Model>>
+}
+export type EncodeCursorResult = string
+export const encodeCursor = <Model>(
+  options: EncodeCursorOptions<Model>,
+): EncodeCursorResult => {
+  const { model, orderBy } = options
+  const encoded = orderBy
+    .map((item) => {
+      const { key } = item
+      if (model[key] === undefined) {
+        throw new Error(`model[${String(key)}] is undefined`)
+      }
+      return model[key]
+    })
+    .map((value) => {
+      if (value instanceof Date) {
+        return `Date(${value.getTime()})`
+      }
+      return String(value)
+    })
+    .join(":")
+  return btoa(encoded)
+}
+
+export interface DecodeCursorOptions<Model, Key extends keyof Model = keyof Model> {
+  modelForType: Model
+  cursor: Cursor
+  orderBy: Array<OrderByItem<Key>>
+}
+export type DecodedCursor<Model, Key extends keyof Model = keyof Model> = {
+  [K in Key]: Model[K] extends Date ? Date : Model[K]
+}
+export type DecodeCursorResult<Model, Key extends keyof Model = keyof Model> = DecodedCursor<Model, Key> | null
+export const decodeCursor = <Model, Key extends keyof Model = keyof Model>(
+  options: DecodeCursorOptions<Model, Key>,
+): DecodeCursorResult<Model, Key> => {
+  const { cursor, orderBy } = options
+  if (cursor === null) {
+    return null
+  }
+  const decoded = atob(cursor)
+    .split(":")
+    .map((value) => {
+      if (value.startsWith("Date(")) {
+        return new Date(Number.parseInt(value.slice(5, -1), 10))
+      }
+      return value
+    })
+    .reduce((acc, value, index) => {
+      const key = orderBy[index]!.key
+      return { ...acc, [key]: value }
+    }, {})
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return decoded as DecodedCursor<Model, Key>
+}
+
+export interface GetNextCursorOptions<Model> {
+  list: Model[]
+  limit: number
+  encodeOptions: Omit<EncodeCursorOptions<Model>, "model">
+}
+export const getNextCursor = <Model>(options: GetNextCursorOptions<Model>): Cursor => {
+  const { list, limit, encodeOptions } = options
+  if (list.length === 0) {
+    return null
+  }
+  if (list.length < limit) {
+    return null
+  }
+  const lastModel = list.at(-1)!
+  const cursor = encodeCursor({
+    model: lastModel,
+    ...encodeOptions,
+  })
+  return cursor
+}
+
+export interface BuildWhereSqlOptions<Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>> {
+  table: Table
+  orderBy: Array<OrderByItem<Key>>
+  decodeCursorResult: DecodeCursorResult<InferModelFromPgTableWithColumns<Table>, Key>
+}
+export const buildWhereSql = <Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>>(
+  options: BuildWhereSqlOptions<Table, Key>,
+): d.SQL | undefined => {
+  const { table, decodeCursorResult, orderBy } = options
+  if (decodeCursorResult === null) {
+    return undefined
+  }
+  if (orderBy.length === 0) {
+    return undefined
+  }
+  const conditionSqlList = orderBy.map((item) => {
+    const { key, order } = item
+    if (order === "asc") {
+      return d.gt(table[key], decodeCursorResult[key])
+    }
+    if (order === "desc") {
+      return d.lt(table[key], decodeCursorResult[key])
+    }
+    throw new Error(`Invalid order: ${String(order)}`)
+  })
+  return d.and(...conditionSqlList)
+}
+
+export interface BuildOrderBySql<Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>> {
+  table: Table
+  orderBy: Array<OrderByItem<Key>>
+}
+export const buildOrderBySql = <Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>>(
+  options: BuildOrderBySql<Table, Key>,
+): d.SQL[] => {
+  const { table, orderBy } = options
+  const sqlList = orderBy.map((item) => {
+    const { key, order } = item
+    if (order === "asc") {
+      return d.asc(table[key])
+    }
+    if (order === "desc") {
+      return d.desc(table[key])
+    }
+    throw new Error(`Invalid order: ${String(order)}`)
+  })
+  return sqlList
+}
+
+export interface BuildCursorBasedPaginationOptions<Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>> {
+  table: Table
+  orderBy: Array<OrderByItem<Key>>
+  cursor: Cursor
+  limit: number
+}
+export interface BuildCursorBasedPaginationResult<Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>> {
+  decodeCursorResult: DecodeCursorResult<InferModelFromPgTableWithColumns<Table>, Key>
+  whereSql: d.SQL | undefined
+  orderBySql: d.SQL[]
+  getNextCursor: (list: Array<InferModelFromPgTableWithColumns<Table>>) => Cursor
+}
+export const buildCursorBasedPagination = <Table extends AnyPgTableWithColumns, Key extends keyof InferModelFromPgTableWithColumns<Table>>(
+  options: BuildCursorBasedPaginationOptions<Table, Key>,
+): BuildCursorBasedPaginationResult<Table, Key> => {
+  const { table, orderBy, limit, cursor } = options
+
+  type Model = InferModelFromPgTableWithColumns<Table>
+
+  const decodeCursorResult = decodeCursor({
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    modelForType: {} as Model,
+    cursor,
+    orderBy,
+  })
+
+  const whereSql = buildWhereSql({
+    table,
+    decodeCursorResult,
+    orderBy,
+  })
+
+  const orderBySql = buildOrderBySql({
+    table,
+    orderBy,
+  })
+
+  const _getNextCursor = (list: Model[]): Cursor => {
+    return getNextCursor({
+      list,
+      limit,
+      encodeOptions: {
+        orderBy,
+      },
+    })
+  }
+
+  return {
+    decodeCursorResult,
+    whereSql,
+    orderBySql,
+    getNextCursor: _getNextCursor,
+  }
+}

package/src/email/README.md

@@ -0,0 +1 @@
+# Email

package/src/email/index.ts

@@ -0,0 +1 @@
+export * from "./resend.ts"

package/src/email/resend.ts

@@ -0,0 +1,25 @@
+import { Resend } from "resend"
+
+export interface SendEmailOptions {
+  from: string
+  to: string
+  subject: string
+  html: string
+}
+export type SendEmailResult = ReturnType<typeof Resend.prototype.emails.send>
+
+export interface EmailOptions {
+  key: string
+}
+export class Email {
+  private sendClient: Resend
+
+  constructor(options: EmailOptions) {
+    const { key } = options
+    this.sendClient = new Resend(key)
+  }
+
+  async sendEmail(options: SendEmailOptions): Promise<SendEmailResult> {
+    return await this.sendClient.emails.send({ ...options })
+  }
+}

package/src/event/class-event-proxy.ts

@@ -1,13 +1,13 @@
 import type { InternalProxySubscriberEntryMap } from "./internal.ts"
 import type {
-  BaseEvents,
+  EventsConstraint,
   SubscriberEntry,
 } from "./common.ts"
 
 /**
  * 表示 ClassEventProxy 用于接入目标实例及其事件系统的适配器。
  */
-export interface ClassEventProxyTargetAdapter<Target, Events extends BaseEvents> {
+export interface ClassEventProxyTargetAdapter<Target, Events extends EventsConstraint<Events>> {
   emit<K extends keyof Events>(target: Target, event: K, ...args: Parameters<Events[K]>): boolean
   subscribe<K extends keyof Events>(target: Target, event: K, subscriber: Events[K]): void
   unsubscribe<K extends keyof Events>(target: Target, event: K, subscriber: Events[K]): void
@@ -16,7 +16,7 @@ export interface ClassEventProxyTargetAdapter<Target, Events extends BaseEvents>
 /**
  * 表示 ClassEventProxy 的构造选项。
  */
-export interface ClassEventProxyOptions<Target, Events extends BaseEvents> {
+export interface ClassEventProxyOptions<Target, Events extends EventsConstraint<Events>> {
   targetAdapter: ClassEventProxyTargetAdapter<Target, Events>
   /**
    * 在代理管理的订阅者执行出错时接收错误与对应订阅项。
@@ -27,7 +27,7 @@ export interface ClassEventProxyOptions<Target, Events extends BaseEvents> {
 /**
  * 将一组目标实例的事件系统适配为统一的代理订阅模型。
  */
-export class ClassEventProxy<Target, Events extends BaseEvents> {
+export class ClassEventProxy<Target, Events extends EventsConstraint<Events>> {
   protected options: ClassEventProxyOptions<Target, Events>
   protected subscribers: Map<Target, InternalProxySubscriberEntryMap<Events>>
 
@@ -196,7 +196,8 @@ export class ClassEventProxy<Target, Events extends BaseEvents> {
 
     const events = Object.keys(proxySubscriberEntryMap)
     for (const event of events) {
-      this.removeSubscribersOfEvent(target, event)
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      this.removeSubscribersOfEvent(target, event as keyof Events)
     }
     this.subscribers.delete(target)
 

package/src/event/common.ts

@@ -4,14 +4,24 @@
 // oxlint-disable-next-line no-explicit-any
 export type BaseSubscriber = (...args: any[]) => void
 /**
- * 表示由事件名到订阅者函数类型构成的事件表。
+ * 表示事件表中允许的事件-订阅者关系的约束类型。
+ * 该类型要求事件表的每个事件都必须对应一个 BaseSubscriber 类型的订阅者函数。
+ * 通过该约束类型，EventManager 和相关组件能够在编译时确保事件表的正确性。
  */
-export type BaseEvents = Record<string, BaseSubscriber>
+export type EventsConstraint<Events extends EventsConstraint<Events>> = {
+  [K in keyof Events]: BaseSubscriber
+}
+export type BuildEvents<Events extends EventsConstraint<Events>> = {
+  [K in keyof Events]: Events[K]
+}
+export interface AnyEvents {
+  [event: string]: BaseSubscriber
+}
 
 /**
  * 表示一次订阅关系的标准化描述。
  */
-export interface SubscriberEntry<Events extends BaseEvents, K extends keyof Events> {
+export interface SubscriberEntry<Events extends EventsConstraint<Events>, K extends keyof Events> {
   event: K
   once: boolean
   subscriber: Events[K]

package/src/event/event-manager.ts

@@ -1,10 +1,10 @@
 import type { InternalSubscriberEntryMap } from "./internal.ts"
-import type { BaseEvents, SubscriberEntry } from "./common.ts"
+import type { EventsConstraint, SubscriberEntry } from "./common.ts"
 
 /**
  * 表示 EventManager 的构造选项。
  */
-export interface EventManagerOptions<Events extends BaseEvents> {
+export interface EventManagerOptions<Events extends EventsConstraint<Events>> {
   /**
    * 在订阅者执行出错时接收错误与对应订阅项。
    */
@@ -14,7 +14,7 @@ export interface EventManagerOptions<Events extends BaseEvents> {
 /**
  * 管理同一事件表下的订阅、取消订阅与事件派发。
  */
-export class EventManager<Events extends BaseEvents> {
+export class EventManager<Events extends EventsConstraint<Events>> {
   protected options: EventManagerOptions<Events>
   /**
    * 每一类事件对应一个内部订阅映射，映射中的 key 是订阅者函数，value 是 SubscriberEntry 对象。

package/src/event/instance-event-proxy.ts

@@ -1,13 +1,13 @@
 import type { InternalProxySubscriberEntryMap } from "./internal.ts"
 import type {
-  BaseEvents,
+  EventsConstraint,
   SubscriberEntry,
 } from "./common.ts"
 
 /**
  * 表示 InstanceEventProxy 用于接入底层事件目标的适配器。
  */
-export interface InstanceEventProxyTargetAdapter<Events extends BaseEvents> {
+export interface InstanceEventProxyTargetAdapter<Events extends EventsConstraint<Events>> {
   emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): boolean
   subscribe<K extends keyof Events>(event: K, subscriber: Events[K]): void
   unsubscribe<K extends keyof Events>(event: K, subscriber: Events[K]): void
@@ -16,7 +16,7 @@ export interface InstanceEventProxyTargetAdapter<Events extends BaseEvents> {
 /**
  * 表示 InstanceEventProxy 的构造选项。
  */
-export interface InstanceEventProxyOptions<Events extends BaseEvents> {
+export interface InstanceEventProxyOptions<Events extends EventsConstraint<Events>> {
   targetAdapter: InstanceEventProxyTargetAdapter<Events>
   /**
    * 在代理管理的订阅者执行出错时接收错误与对应订阅项。
@@ -27,7 +27,7 @@ export interface InstanceEventProxyOptions<Events extends BaseEvents> {
 /**
  * 将单个事件目标适配为可管理下游订阅关系的代理。
  */
-export class InstanceEventProxy<Events extends BaseEvents> {
+export class InstanceEventProxy<Events extends EventsConstraint<Events>> {
   protected options: InstanceEventProxyOptions<Events>
   protected subscribers: InternalProxySubscriberEntryMap<Events>
 
@@ -168,7 +168,8 @@ export class InstanceEventProxy<Events extends BaseEvents> {
     const events = Object.keys(this.subscribers)
 
     for (const event of events) {
-      this.removeSubscribersOfEvent(event)
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      this.removeSubscribersOfEvent(event as keyof Events)
     }
     this.subscribers = {}
 

package/src/event/internal.ts

@@ -1,9 +1,9 @@
-import type { BaseEvents, SubscriberEntry } from "./common.ts"
+import type { EventsConstraint, SubscriberEntry } from "./common.ts"
 
 /**
  * 表示某一事件名下由订阅者函数到订阅项的内部映射。
  */
-export type InternalSubscriberEntryMap<Events extends BaseEvents, K extends keyof Events> = Map<
+export type InternalSubscriberEntryMap<Events extends EventsConstraint<Events>, K extends keyof Events> = Map<
   Events[K],
   SubscriberEntry<Events, K>
 >
@@ -11,7 +11,7 @@ export type InternalSubscriberEntryMap<Events extends BaseEvents, K extends keyo
 /**
  * 表示代理订阅项及其所管理的下游订阅集合的内部结构。
  */
-export interface InternalProxySubscriberEntry<Events extends BaseEvents, K extends keyof Events> {
+export interface InternalProxySubscriberEntry<Events extends EventsConstraint<Events>, K extends keyof Events> {
   managedSubscribers: InternalSubscriberEntryMap<Events, K>
   proxySubscriber: Events[K]
 }
@@ -19,6 +19,6 @@ export interface InternalProxySubscriberEntry<Events extends BaseEvents, K exten
 /**
  * 使用对象而非 Map 来保存事件到代理订阅项的内部映射。
  */
-export type InternalProxySubscriberEntryMap<Events extends BaseEvents> = {
+export type InternalProxySubscriberEntryMap<Events extends EventsConstraint<Events>> = {
   [K in keyof Events]?: InternalProxySubscriberEntry<Events, K> | undefined
 }

package/src/form/README.md

@@ -0,0 +1,25 @@
+# Form
+
+## Description
+
+Form 模块提供围绕类表单输入项（form-like input）及其组合关系的通用建模能力，用于表达输入状态、值转换与聚合边界。
+
+它关注的不是某个组件库的渲染细节，也不是某个框架各自的表单接入方式，而是“一个输入项应如何被视为可独立管理的输入原子、多个输入项如何组合成更高层的类表单数据管理器、以及输入值与聚合值如何保持清楚且可维护的对应关系”这一类基础问题。它之所以被命名为 Form，不是因为它只服务于页面表单，而是因为表单场景最自然、最直观地体现了这类模型的价值。
+
+## For Understanding
+
+理解 Form 模块时，首先应把它看成“类表单数据管理模型”，而不是“页面表单组件集合”或“校验规则工具箱”。它要解决的问题，不是把某个现成表单 API 重新包装一遍，而是为输入项本身建立稳定语义：一个输入项有哪些核心状态，输入过程与最终值如何区分，多个输入项如何组合，以及组合之后的整体值应如何被表达。
+
+这个模块更适合放在以下边界中：
+
+- 你希望把输入逻辑从具体接入层中抽离出来，让输入状态、值更新和聚合关系可以在不同 UI、服务端流程或其它非界面场景之间复用。
+- 你需要先把输入项视为一组可独立管理的输入原子，再把它们组合成更高层的类表单数据管理器，而不是一开始就把所有逻辑揉成单个大对象。
+- 你需要明确区分“输入过程中的值”和“对外稳定表达的值”，并希望这种区分能够成为长期可维护的公共语义。
+
+理解这个模块时，还应守住几条边界原则：
+
+- Form 模块表达的是输入项状态、输入项组合与值映射语义，不负责页面布局、样式、校验文案或具体提交流程。
+- 它可以服务于具体输入组件，但不应因为适配某个框架或某种表单交互习惯，而把这些宿主细节直接上升为模块公共语义。
+- 它关注的是“输入项如何被建模、如何更新、如何聚合”，而不是所有表单相关问题的总容器；像复杂校验编排、错误展示策略、网络提交流程或业务字段规范，通常应由更上层模块承担。
+
+因此，更合适的理解方式是：Form 模块提供的是一套围绕输入原子与类表单聚合的数据管理基础模型能力。表单只是它最典型的落点之一，而不是它的唯一归宿。只有当某个能力确实在澄清这条边界时，它才适合作为该模块的组成部分；如果某个能力只是某类页面表单的临时便利封装，那么它通常不应直接进入这个模块。

package/src/form/index.ts

@@ -0,0 +1 @@
+export * from "./inputor-controller/index.ts"