lecodes-cli 0.19.0 → 0.19.2

package/runtime/sdk/server/host.ts

@@ -1,74 +0,0 @@
-/**
- * `sdk/server` — the HOST side of the app backend, imported normally by the runner
- * (packages/lecodes-runner), the backend and tests. Nothing here is bundled into project code; the
- * bundle carries its own SDK copy and meets this module only through the `globalThis.__lecodes*`
- * seams (see ./runtime.ts).
- */
-
-export {
-  loadServerModules, createInvoker, createJoinGuard, setChannelPublisher, setRequestProvider,
-} from "./runtime"
-export type { LoadedServer, InvokeResult, InvokerOptions, ServerRegistration } from "./runtime"
-export type { RequestContext } from "./context"
-export { setDbTransport } from "./db/defineDb"
-export { marciHttpTransport, marciRequest, encodeMarciId, MarciHttpError } from "./db/httpTransport"
-export type { MarciHttpOptions } from "./db/httpTransport"
-export type { MarciOp, MarciTransport } from "./db/marci/query"
-export type { ServerManifest, ServerExport } from "../compile/serverSplit"
-export { validateArgs, ValidationError } from "./validate"
-export type { ParamSchema, Schema as ParamSchemaNode } from "./validate"
-export { createAuthHost, signNonce, verifyNonce, sha256 } from "./auth/host"
-export type { AuthHost, AuthHostConfig, AuthMail } from "./auth/host"
-export type { AuthUser, AuthState, AuthOps, OAuthProfile, OAuthCredential } from "./auth/types"
-export type { AuthProvider, AppConfig } from "./auth/appConfig"
-
-import type { LoadedServer } from "./runtime"
-import type { Field, FieldDef } from "./db/fields"
-import type { Model } from "./db/types"
-
-/** JSON view of one field for the platform (Data tab, docs): `FieldDef` with nested struct fields flattened
- *  to defs and functions/undefineds dropped. */
-export type FieldDescription = Omit<FieldDef, "fields" | "default"> & { fields?: Record<string, FieldDescription>, default?: unknown }
-
-/** What the runner reports to the platform after loading a bundle: schema text + models + the
- *  endpoint/channel lists (with the manifest's param schemas). */
-export type ServerDescription = {
-  /** `.marci` schema text ("" when the project defines no db). */
-  marci: string
-  models: Record<string, { fields: Record<string, FieldDescription> }>
-  endpoints: { id: string, params: unknown[] | null }[]
-  channels: string[]
-  /** Which models the auth runtime binds to (`null` = the project has no db) and the app.json providers. */
-  auth: { user: string | null, session: string | null, providers: string[] }
-  /** `app.json` name (when the compile embedded one). */
-  appName?: string
-}
-
-const describeField = (f: Field<any, any>): FieldDescription => {
-  const def = f.def
-  const out: FieldDescription = { ...def, fields: undefined, default: undefined }
-  delete out.fields
-  delete out.default
-  if (def.hasDefault) out.default = def.default === undefined ? null : def.default
-  if (def.fields) out.fields = Object.fromEntries(Object.entries(def.fields).map(([k, v]) => [k, describeField(v)]))
-  return JSON.parse(JSON.stringify(out))
-}
-
-export const describeServer = (server: LoadedServer): ServerDescription => {
-  const db = server.dbs[0]
-  const models: ServerDescription["models"] = {}
-  if (db) {
-    for (const [name, m] of Object.entries(db.$models as Record<string, Model>)) {
-      models[name] = { fields: Object.fromEntries(Object.entries(m.fields as Record<string, Field<any, any>>).map(([k, f]) => [k, describeField(f)])) }
-    }
-  }
-  const params = (server.manifest.params ?? {}) as Record<string, unknown[]>
-  return {
-    marci: db?.$schema ?? "",
-    models,
-    endpoints: [...server.endpoints.keys()].map(id => ({ id, params: params[id] ?? null })),
-    channels: [...server.channels.keys()],
-    auth: { user: db?.$auth.user ?? null, session: db?.$auth.session ?? null, providers: server.manifest.app?.auth?.providers ?? [] },
-    appName: server.manifest.app?.name,
-  }
-}

package/runtime/sdk/server/inject.ts

@@ -1,13 +0,0 @@
-/*
- * The SERVER inject module — the globals available in `*.server.ts` files (docs/backend-plan.md §4).
- * chisel injects these into the server bundle exactly like ./inject.ts does for the client bundle;
- * nothing here may reach the client bundle. Keep this the ONLY file that exports server globals.
- *
- * Globals: t, model, defineDb, ref (schema + queries), ApiError, channel, request, auth.
- */
-
-export { t, model, defineDb, ref } from "./db"
-export { ApiError } from "./errors"
-export { channel } from "./channel"
-export { request } from "./context"
-export { auth } from "./auth/global"

package/runtime/sdk/server/runtime.ts

@@ -1,133 +0,0 @@
-/**
- * Host side of a compiled server bundle — used by the runner (packages/lecodes-runner) and by tests.
- * Imported normally (Node/Bun), NOT through chisel: the bundle carries its own SDK copy and talks
- * to this module only through globals (`__lecodesServer`, `__lecodesRequest`, `__lecodesPublish`).
- *
- *   evaluate the bundle (it sets globalThis.__lecodesServer)
- *   const server = loadServerModules()          // classify exports, name channels
- *   const invoke = createInvoker(server)        // validate → run in request context → envelope
- *   await invoke("notes.server.ts#listNotes", [20], { headers, ip })
- */
-
-import { AsyncLocalStorage } from "node:async_hooks"
-import type { ServerManifest } from "../compile/serverSplit"
-import type { AuthHost } from "./auth/host"
-import type { AuthState } from "./auth/types"
-import { setChannelPublisher, type Channel } from "./channel"
-import { setRequestProvider, type RequestContext } from "./context"
-import type { Db } from "./db/types"
-import { takeRegisteredDbs } from "./db/defineDb"
-import { validateArgs, ValidationError, type ParamSchema } from "./validate"
-
-export type ServerRegistration = { modules: Record<string, Record<string, unknown>>, manifest: ServerManifest }
-
-export type LoadedServer = {
-  endpoints: Map<string, (...args: any[]) => unknown>
-  channels: Map<string, Channel<any>>
-  /** Every `defineDb` handle — exported or not (the bundle registers them on globalThis; normally exactly one). */
-  dbs: Db<any>[]
-  manifest: ServerManifest
-}
-
-const isDb = (v: unknown): v is Db<any> => typeof v === "object" && v !== null && typeof (v as Db<any>).$schema === "string"
-const isChannel = (v: unknown): v is Channel<any> => typeof v === "object" && v !== null && (v as Channel<any>).__channel === true
-
-/** Read the registration a server bundle left on `globalThis.__lecodesServer` (or a given one). */
-export const loadServerModules = (
-  reg: ServerRegistration | undefined = (globalThis as any).__lecodesServer,
-): LoadedServer => {
-  if (!reg) throw new Error("loadServerModules: no server bundle registered (globalThis.__lecodesServer)")
-  const out: LoadedServer = { endpoints: new Map(), channels: new Map(), dbs: [], manifest: reg.manifest }
-  for (const [mod, exports] of Object.entries(reg.modules)) {
-    for (const [name, value] of Object.entries(exports)) {
-      const id = `${mod}#${name}`
-      if (typeof value === "function") out.endpoints.set(id, value as (...args: any[]) => unknown)
-      else if (isChannel(value)) { value.__id = id; out.channels.set(id, value) }
-      else if (isDb(value)) out.dbs.push(value)
-    }
-  }
-  // Non-exported handles (`const db = defineDb(...)`): the bundle's SDK copy registered them on globalThis.
-  for (const db of takeRegisteredDbs()) if (!out.dbs.includes(db)) out.dbs.push(db)
-  return out
-}
-
-/** The wire envelope. `session` = a token the client must store from now on (new guest session / rotation). */
-export type InvokeResult =
-  | { ok: true, result: unknown, session?: string }
-  | { ok: false, status: number, message: string, session?: string }
-
-export type InvokerOptions = {
-  /** Validate args against the manifest's param schemas (default true; endpoints without a schema pass). */
-  validate?: boolean
-  /** Where unexpected (non-ApiError) failures are reported. Default: console.error. */
-  onError?: (id: string, error: unknown) => void
-  /** The auth host (./auth/host.ts): resolves the bearer token into `ctx.auth` before each call. Absent = no sessions. */
-  auth?: AuthHost | null
-}
-
-// The bundle's ApiError is a different class object than ours (its own SDK copy) — duck-type it.
-const apiStatus = (e: unknown): number | null =>
-  e && typeof e === "object" && (e as { name?: string }).name === "ApiError" && typeof (e as { status?: unknown }).status === "number"
-    ? (e as { status: number }).status : null
-
-/**
- * Build the invoker: `invoke(id, args, ctx)` runs endpoint `id` inside an AsyncLocalStorage-scoped
- * request context (what the `request`/`auth` globals read) and returns the wire envelope.
- */
-// One request store for endpoints AND channel guards (a second store would steal the provider).
-const als = new AsyncLocalStorage<RequestContext>()
-const installProvider = () => setRequestProvider(() => als.getStore())
-
-// A token minted/rotated during the call rides on the envelope (the client transport stores it).
-const withSession = (r: InvokeResult, rc: RequestContext): InvokeResult => {
-  const issued = (rc.auth as AuthState | undefined)?.issuedToken
-  return issued ? { ...r, session: issued } : r
-}
-
-export const createInvoker = (server: LoadedServer, opts: InvokerOptions = {}) => {
-  installProvider()
-  const validate = opts.validate ?? true
-  const onError = opts.onError ?? ((id, e) => console.error(`[server] ${id}:`, e))
-  const params = server.manifest.params as Record<string, ParamSchema[]> | undefined
-  const auth = opts.auth ?? null
-
-  return async (id: string, args: unknown[], ctx: Omit<RequestContext, "id"> = { headers: {} }): Promise<InvokeResult> => {
-    const fn = server.endpoints.get(id)
-    if (!fn) return { ok: false, status: 404, message: `Unknown endpoint ${id}` }
-    if (!Array.isArray(args)) return { ok: false, status: 400, message: "args must be an array" }
-    const rc: RequestContext = { ...ctx, id }
-    try {
-      if (validate && params?.[id]) validateArgs(params[id], args)
-      if (auth) await auth.resolve(rc)
-      const result = await als.run(rc, () => fn(...args))
-      return withSession({ ok: true, result: result === undefined ? null : result }, rc)
-    } catch (e) {
-      const status = apiStatus(e)
-      if (status !== null) return withSession({ ok: false, status, message: (e as Error).message }, rc)
-      if (e instanceof ValidationError) return { ok: false, status: 400, message: e.message }
-      onError(id, e)
-      return withSession({ ok: false, status: 500, message: "Internal error" }, rc)
-    }
-  }
-}
-
-/** Run a channel's `onJoin` guard for a subscription (same request scoping as endpoints). */
-export const createJoinGuard = (server: LoadedServer, opts: Pick<InvokerOptions, "auth"> = {}) => {
-  installProvider()
-  const auth = opts.auth ?? null
-  return async (channelId: string, topic: string, ctx: Omit<RequestContext, "id"> = { headers: {} }): Promise<InvokeResult> => {
-    const ch = server.channels.get(channelId)
-    if (!ch) return { ok: false, status: 404, message: `Unknown channel ${channelId}` }
-    const rc: RequestContext = { ...ctx, id: channelId }
-    try {
-      if (auth) await auth.resolve(rc)
-      await als.run(rc, () => ch.options.onJoin?.(topic))
-      return withSession({ ok: true, result: null }, rc)
-    } catch (e) {
-      const status = apiStatus(e)
-      return withSession({ ok: false, status: status ?? 500, message: status !== null ? (e as Error).message : "Internal error" }, rc)
-    }
-  }
-}
-
-export { setChannelPublisher, setRequestProvider }

package/runtime/sdk/server/validate.ts

@@ -1,87 +0,0 @@
-/**
- * Runtime validation of endpoint arguments against the compact schemas the compiler derives from the
- * TypeScript parameter types (src/compile/serverTypes.ts). Dependency-free; the schema is JSON so it
- * travels inside the server bundle's manifest.
- */
-
-export type Schema =
-  | { t: "any" }
-  | { t: "string" } | { t: "number" } | { t: "boolean" } | { t: "null" } | { t: "undefined" }
-  | { t: "lit", v: string | number | boolean }
-  | { t: "array", of: Schema }
-  | { t: "tuple", items: Schema[], rest?: Schema }
-  | { t: "object", props: Record<string, Schema>, optional?: string[], index?: Schema }
-  | { t: "union", of: Schema[] }
-
-/** One endpoint parameter: its schema and whether it may be omitted (`?`, default value, rest). */
-export type ParamSchema = { name: string, schema: Schema, optional?: boolean, rest?: boolean }
-
-export class ValidationError extends Error {
-  readonly status = 400
-  constructor(message: string) { super(message); this.name = "ValidationError" }
-}
-
-const typeName = (v: unknown) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v
-
-/** Returns the first problem as a message, or null when `value` matches. */
-export const check = (schema: Schema, value: unknown, path: string): string | null => {
-  switch (schema.t) {
-    case "any": return null
-    case "string": case "number": case "boolean":
-      return typeof value === schema.t ? null : `${path}: expected ${schema.t}, got ${typeName(value)}`
-    case "null": return value === null ? null : `${path}: expected null, got ${typeName(value)}`
-    case "undefined": return value === undefined ? null : `${path}: expected undefined, got ${typeName(value)}`
-    case "lit": return value === schema.v ? null : `${path}: expected ${JSON.stringify(schema.v)}, got ${JSON.stringify(value)}`
-    case "array":
-      if (!Array.isArray(value)) return `${path}: expected array, got ${typeName(value)}`
-      for (let i = 0; i < value.length; i++) { const e = check(schema.of, value[i], `${path}[${i}]`); if (e) return e }
-      return null
-    case "tuple": {
-      if (!Array.isArray(value)) return `${path}: expected tuple, got ${typeName(value)}`
-      if (value.length < schema.items.length || (!schema.rest && value.length > schema.items.length))
-        return `${path}: expected ${schema.items.length} items, got ${value.length}`
-      for (let i = 0; i < value.length; i++) {
-        const s = i < schema.items.length ? schema.items[i] : schema.rest!
-        const e = check(s, value[i], `${path}[${i}]`); if (e) return e
-      }
-      return null
-    }
-    case "object": {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) return `${path}: expected object, got ${typeName(value)}`
-      const obj = value as Record<string, unknown>
-      const optional = new Set(schema.optional ?? [])
-      for (const [k, s] of Object.entries(schema.props)) {
-        if (!(k in obj) || obj[k] === undefined) { if (optional.has(k)) continue; return `${path}.${k}: required` }
-        const e = check(s, obj[k], `${path}.${k}`); if (e) return e
-      }
-      for (const k of Object.keys(obj)) {
-        if (k in schema.props) continue
-        if (schema.index) { const e = check(schema.index, obj[k], `${path}.${k}`); if (e) return e }
-        // unknown keys without an index signature are ignored (structural typing)
-      }
-      return null
-    }
-    case "union": {
-      const errors: string[] = []
-      for (const s of schema.of) { const e = check(s, value, path); if (!e) return null; errors.push(e) }
-      return `${path}: no union member matched (${errors.join("; ")})`
-    }
-  }
-}
-
-/** Validate a positional argument list. Extra arguments are ignored (JS call semantics). */
-export const validateArgs = (params: ParamSchema[], args: unknown[]): void => {
-  for (let i = 0; i < params.length; i++) {
-    const p = params[i]
-    if (p.rest) {
-      const rest = args.slice(i)
-      const e = check(p.schema, rest, p.name)
-      if (e) throw new ValidationError(e)
-      return
-    }
-    const v = args[i]
-    if (v === undefined) { if (p.optional) continue; throw new ValidationError(`${p.name}: required`) }
-    const e = check(p.schema, v, p.name)
-    if (e) throw new ValidationError(e)
-  }
-}

package/runtime/sdk/ui/NativeView.ts

@@ -1,142 +0,0 @@
-// A host-registered platform view (map, QR scanner, camera preview, …) — the plugin surface of
-// the Presentable model (docs/navigation-presentable-plan.md). The host registers a *capability*
-// (`engine.registerView("map") { params, channel -> MapView(...) }`); when and with what to show
-// it is app code. Dual-natured like every Presentable: a fullscreen destination
-// (`Router.push(map)` / `map.open()`) AND an embeddable layout node (wire type `"native"` — place
-// it among a screen's children, sized by its styles). One instance lives in one place at a time;
-// pushing a mounted instance fullscreen is promotion (the native view reparents, state intact).
-//
-// Plugins ship a typed TS wrapper over the raw `call`/`on` channel — see QRScanner for the
-// wrapper convention.
-
-import { _channelCall, _channelEmit, _channelOff, _channelOn, type ChannelListeners } from "../runtime/channel"
-import { _bumpNavEpoch, _navSupported, _setCurrent, Presentable, type PresentOptions } from "./presentable"
-import { Element, type BaseStyle, type DrawableStyle, type ElementStyle, type UIElementBase } from "./UINode"
-
-export type UINativeViewStyle = ElementStyle & DrawableStyle
-
-/** An instance of a host-registered platform view (map, QR scanner, camera preview, …) —
- *  embeddable among a screen's children AND fullscreen-presentable (`open()`); one instance lives
- *  in one place at a time. Talk to it via the `call`/`on` channel. */
-export interface NativeView extends UIElementBase<UINativeViewStyle, DrawableStyle & BaseStyle> {
-  readonly type: "native",
-  /** The registered view kind this instance resolves to (the `registerView` name). */
-  readonly viewName: string,
-  /** Creation params, passed to the host factory (JSON-serializable). */
-  readonly params: any,
-
-  /** Show fullscreen as the current destination (see Presentable). */
-  open(options?: PresentOptions): void,
-  /** Dismiss if this is the visible destination. */
-  close(): void,
-
-  /** Became the visible destination. */
-  onOpen(callback: () => void): this
-  /** Stopped being the visible destination. */
-  onClose(callback: () => void): this
-  /** Hardware/system back while current. */
-  onBackPressed(callback: () => void): this
-
-  /** Invoke a method on the native view (`map.call("setCenter", [lng, lat])`). Args and the
-   *  result are JSON-serialized. Rejects if the host has no such view/method. */
-  call(method: string, ...args: any[]): Promise<any>
-  /** Subscribe to an event the native view emits (`map.on("markerTap", cb)`). */
-  on(event: string, callback: (data?: any) => void): this
-  off(event: string, callback: (data?: any) => void): this
-}
-
-let nextViewId = 1
-
-/** @internal Base for typed plugin wrappers (QRScanner, CameraView — src/plugins/): subclass it,
- *  pin the viewName/params, and layer typed methods over the raw `call`/`on` channel. Not a
- *  public global — apps use the `NativeView(name)` factory below. */
-export class NativeViewElement extends Element<"native"> implements Presentable {
-  readonly viewName: string
-  readonly params: any
-  /** @internal stable per-instance handle for the viewCall channel + promotion identity. */
-  readonly _viewId: number
-  /** @internal event listeners by event name — the host invokes these (vlist pcl/psl convention)
-   *  or calls _emitViewEvent. */
-  readonly nvl: ChannelListeners = {}
-  readonly ol: (() => void)[] = []
-  readonly cl: (() => void)[] = []
-  _backButtonCallback?: () => void
-  private _vd?: object
-
-  constructor(viewName: string, params: any) {
-    super("native", {})
-    this.viewName = viewName
-    this.params = params
-    this._viewId = nextViewId++
-  }
-
-  /** @internal stable wire descriptor; hosts hand it back via router onChange (`_p` = this). */
-  _viewDesc(): object {
-    return this._vd ??= { type: "native", viewName: this.viewName, params: this.params, viewId: this._viewId, _p: this }
-  }
-
-  open(options?: PresentOptions): void {
-    if (!_navSupported()) {
-      throw new Error(`NativeView("${this.viewName}") is not supported on this host (requires _creatorUI.openView)`)
-    }
-    _bumpNavEpoch()
-    _creatorUI.openView!(this._viewDesc(), options?.transition ?? "none")
-    _setCurrent(this)
-  }
-  close(): void {
-    _bumpNavEpoch()
-    if (_navSupported()) _creatorUI.closeView!()
-    if (Presentable.current === this) _setCurrent(null)
-  }
-
-  onOpen(callback: () => void): this {
-    this.ol.push(callback)
-    return this
-  }
-  onClose(callback: () => void): this {
-    this.cl.push(callback)
-    return this
-  }
-  onBackPressed(callback: () => void): this {
-    this._backButtonCallback = callback
-    return this
-  }
-
-  call(method: string, ...args: any[]): Promise<any> {
-    return _channelCall(
-      typeof _creatorUI !== "undefined" ? _creatorUI : undefined, "viewCall",
-      `NativeView("${this.viewName}") is not supported on this host (requires _creatorUI.viewCall)`,
-      this._viewId, method, args)
-  }
-
-  on(event: string, callback: (data?: any) => void): this {
-    _channelOn(this.nvl, event, callback)
-    return this
-  }
-  off(event: string, callback: (data?: any) => void): this {
-    _channelOff(this.nvl, event, callback)
-    return this
-  }
-  /** @internal host entry: deliver a native event (payload as a JSON string, or omitted). */
-  _emitViewEvent(event: string, dataJson?: string): void {
-    _channelEmit(this.nvl, event, dataJson)
-  }
-}
-
-/**
- * Create an instance of a host-registered platform view. `NativeView.isSupported(name)` reports
- * whether this host registered a factory for it. Style via the chained `.style()`.
- */
-// PURE IIFE (not a plain function + expando assignment) so an app that never uses NativeView
-// tree-shakes it away — top-level property assignments read as side effects to the bundler.
-export const NativeView: {
-  (name: string, params?: object): NativeView
-  /** Whether this host registered a `registerView` factory under `name`. */
-  isSupported(name: string): boolean
-} = /*#__PURE__*/ (() => {
-  const factory = (name: string, params: object = {}): NativeView =>
-    new NativeViewElement(name, params) as unknown as NativeView
-  factory.isSupported = (name: string): boolean =>
-    typeof _creatorUI !== "undefined" && typeof _creatorUI.isViewSupported === "function" && _creatorUI.isViewSupported(name)
-  return factory
-})()

package/runtime/sdk/ui/UI.ts

@@ -1,39 +0,0 @@
-// Renderer-side contract + per-renderer status (DOM / canvas-ui / desktop) for every component
-// below is tracked in packages/canvas-ui/COMPONENTS.md.
-export { UIButton, type UIButtonStyle } from './UIButton'
-export { UIScreen, type UIScreenStyle } from './UIScreen'
-export { UISpacer, type UISpacerStyle } from './UISpacer'
-export { UIText, type UITextStyle } from './UIText'
-export { registerFont } from './fonts'
-export { UIImage, type UIImageStyle } from './UIImage'
-export { UIVideo, type UIVideoStyle } from './UIVideo'
-export { UIInput, UITextArea, type UIInputStyle } from './UIInput'
-
-export { UIWidget, type UIWidgetStyle } from './UIWidget'
-export { UIModal, type UIModalStyle } from './UIModal'
-export { UIBottomSheet, type UIBottomSheetStyle } from './UIBottomSheet'
-export { UIPopover, type UIPopoverStyle, type UIPopoverAnchor } from './UIPopover'
-
-export { UIRow, UIColumn, UIBox, type UIContainerStyle } from './UIContainer'
-export { UIScrollable, type UIScrollableStyle } from './UIScrollable'
-export { UIPager, type UIPagerStyle } from './UIPager'
-export { UITabs, type UITabDef, defineTabs, type TabDef, type TabsHandle } from './UITabs'
-
-export { UIVirtualizedList } from './UIVirtualizedList'
-
-export { Router } from './router'
-export { NativeView, type UINativeViewStyle } from './NativeView'
-// Presentable is both the interface and its runtime companion (Presentable.current).
-export { Presentable } from './presentable'
-export type { PresentOptions, Transition, TransitionName, TransitionSpec, TransitionTransform } from './presentable'
-
-// Internal: memoized map for reactive children — the chisel `reactiveUi` pass rewrites
-// `list.map(fn)` inside children bindings to `__uiMap(list, fn, slot)` calls.
-export { __uiMap } from './UINode'
-// Compiler fast paths (chisel `flatten_ui` raw lowering): dispatch-free construction for calls
-// whose arguments the compiler proved to be plain children. Never written by hand.
-export { __UIColumn, __UIRow, __UIBox } from './UIContainer'
-export { __UIButton } from './UIButton'
-export { __UIScreen } from './UIScreen'
-export { __UIScrollable } from './UIScrollable'
-export { __UIWidget } from './UIWidget'

package/runtime/sdk/ui/UIBottomSheet.ts

@@ -1,139 +0,0 @@
-import { ModalElement, type UIModalStyle } from "./UIModal"
-import type { UIWidget } from "./UIWidget"
-import { buildUI, type ChildrenFn, type UIChildArg, type UINodeChild } from "./UINode"
-
-export type UIBottomSheetStyle = UIModalStyle
-
-const SHEET_ANIM_MS = 250
-
-/**
- * A bottom sheet: a `UIWidget` pinned to the bottom edge. By default it is **content-sized** —
- * as tall as what's inside (capped at the screen), one position, drag down to dismiss (the
- * action-sheet shape). Call `detents()` for the multi-position map-app model instead: snap
- * positions the user drags between on native hosts. Ships as a widget node on the wire (no new
- * node type — docs/bottom-sheet-plan.md): hosts without sheet support show a static bottom panel.
- *
- * With detents, content lays out at the HIGHEST detent's size; lower detents show the top
- * slice. The scrim, `onOpen`/`onClose`, back-button and scrim-tap dismissal all come from the
- * modal machinery.
- *
- * ```ts
- * const actions = UIBottomSheet({ bgColor: "#1c1c1e", borderRadius: 16 }, [rows])   // content-sized
- *
- * const mapSheet = UIBottomSheet({ bgColor: "#1c1c1e", borderRadius: 16 }, [results])
- *   .detents([0.3, 0.6, 1])
- *   .onDetentChange(i => map.setPadding(...))
- * ```
- */
-export interface UIBottomSheet extends UIWidget {
-  /** Snap positions as fractions of screen height, ascending. Also sizes the sheet: its box is
-   *  the last (highest) detent; set this before `show()`. Without a `detents()` call the sheet
-   *  is CONTENT-SIZED instead — one position, as tall as its children (up to the screen). */
-  detents(list: number[]): this,
-  /** Snap to a detent (animated). Clamped to the detents range; fires `onDetentChange`. */
-  setDetent(index: number): void,
-  /** Current detent index. */
-  readonly detent: number,
-  /** Fires on every settle: a finger snap on native hosts, or a `setDetent()` call. */
-  onDetentChange(callback: (index: number) => void): this,
-
-  /** Mount and slide in to the current detent. No-op while already open. */
-  show(): void,
-  /** Slide out, fade the scrim, then unmount. No-op while closed. */
-  hide(): void,
-  /** True from `show()` until `hide()` starts. */
-  readonly isOpen: boolean,
-
-  /** Called when `show()` mounts the sheet. */
-  onOpen(callback: () => void): this,
-  /** Called when the sheet starts closing — scrim tap, back button, drag-dismiss, or `hide()`. */
-  onClose(callback: () => void): this,
-  /** `dismissible(false)`: scrim taps, the back button and dragging below the lowest detent no
-   *  longer close the sheet (a drag collapses to the lowest detent instead). Default `true`. */
-  dismissible(enabled: boolean): this,
-}
-
-export class BottomSheetElement extends ModalElement {
-  _detents: number[] = [1]
-  _detent = 0
-  /** Host-facing (the `sl`/`otl` contract): hosts read `dtl` at mount and call it with the
-   *  settled detent index for GESTURE settles only — programmatic `setDetent` fires JS-side.
-   *  `-1` = dragged below the lowest detent while dismissible. */
-  readonly dtl: any[] = []
-  readonly _detentListeners: ((index: number) => void)[] = []
-
-  constructor(style: UIBottomSheetStyle, children: UINodeChild[] | ChildrenFn) {
-    // No default height: an absolute node with only bottom set is CONTENT-sized by yoga. A
-    // single detent makes the geometry height-independent on every host (shown = offset 0,
-    // hidden = own height), so content mode needs no host support beyond the detents path.
-    super({ left: 0, right: 0, bottom: 0, maxHeight: "100%", sheetDetents: "1", ...style } as UIModalStyle, children)
-    // The inherited show/hide pose animates ONLY the scrim: sheet geometry rides the
-    // sheetDetent style key, never the pose system.
-    this._transition = { duration: SHEET_ANIM_MS }
-    this.dtl.push((index: number) => {
-      if (index < 0) { this.hide(); return }
-      this._detent = index
-      for (const callback of this._detentListeners) callback(index)
-    })
-  }
-
-  detents(list: number[]): this {
-    const sorted = [...list].filter(d => d > 0).sort((a, b) => a - b)
-    if (sorted.length === 0) return this
-    this._detents = sorted
-    if (this._detent >= sorted.length) this._detent = sorted.length - 1
-    this.style({
-      height: `${sorted[sorted.length - 1] * 100}%`,
-      sheetDetents: sorted.join(","),
-    } as UIBottomSheetStyle)
-    return this
-  }
-
-  get detent(): number {
-    return this._detent
-  }
-
-  setDetent(index: number): void {
-    const clamped = Math.max(0, Math.min(Math.floor(index), this._detents.length - 1))
-    this._detent = clamped
-    if (!this._open) return                     // applied by the next show()
-    this.style({ sheetDetent: clamped } as UIBottomSheetStyle)
-    for (const callback of this._detentListeners) callback(clamped)
-  }
-
-  onDetentChange(callback: (index: number) => void): this {
-    this._detentListeners.push(callback)
-    return this
-  }
-
-  show(): void {
-    if (this._open) return
-    // Before the mount, so the built node carries the target and hosts play the entrance to it.
-    this.style({ sheetDetent: this._detent } as UIBottomSheetStyle)
-    super.show()
-  }
-
-  hide(): void {
-    if (!this._open) return
-    this.style({ sheetDetent: -1 } as UIBottomSheetStyle)   // hosts slide out; unmount follows
-    super.hide()
-  }
-
-  dismissible(enabled: boolean): this {
-    super.dismissible(enabled)
-    this.style({ sheetDismissible: enabled ? 1 : 0 } as UIBottomSheetStyle)
-    return this
-  }
-}
-
-const makeBottomSheet = (style: any, children: any) => new BottomSheetElement(style, children)
-
-/** Create a bottom sheet (see {@link UIBottomSheet}) — content-sized by default; call
- *  `.detents([...])` for snap positions. Same argument forms as `UIColumn`. */
-export function UIBottomSheet(...children: UIChildArg[]): UIBottomSheet;
-export function UIBottomSheet(children: UINodeChild[] | ChildrenFn): UIBottomSheet;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export function UIBottomSheet(style: UIBottomSheetStyle, children?: UINodeChild[] | ChildrenFn): UIBottomSheet;
-export function UIBottomSheet(...args: any[]): UIBottomSheet {
-  return buildUI(args, null, makeBottomSheet)
-}