lecodes-sdk 1.2.0 → 2.0.1

package/src/gl/touch.ts

@@ -2,17 +2,18 @@
 // the struck Node and to the active scene's listeners. Ported from worker/src/TouchEventSystem.ts.
 
 import { ClickEvent, TouchStartEvent, type TrackHandler } from "../runtime/touch"
-import { nodeRegistry } from "./Node"
+import { ensureEmitter, setSceneTouchHandlers } from "../ui/tree"
+import { nodes } from "./Node"
 import { glState } from "./state"
 
 // Hits inside a loaded model (GLB) land on sub-entities the user never created a Node for — walk up
 // the transform hierarchy to the nearest entity someone actually holds (the model's Node).
 const resolveHitNode = (entityId: number) => {
-  let node = nodeRegistry.get(entityId)
+  let node = nodes.get(entityId)
   for (let id = entityId, i = 0; !node && i < 32; i++) {
     id = _creator.getParent(id)
     if (id === 0) break
-    node = nodeRegistry.get(id)
+    node = nodes.get(id)
   }
   return node ?? null
 }
@@ -53,16 +54,14 @@ const onTouchStart = (pointerId: number, clientX: number, clientY: number, entit
   return null
 }
 
-let touchStartRegistered = false
-export const registerTouchStartEvent = (): void => {
-  if (touchStartRegistered) return
-  touchStartRegistered = true
-  _creatorUI.registerTouchStartEvent(onTouchStart)
-}
-
-let touchEndRegistered = false
-export const registerTouchEndEvent = (): void => {
-  if (touchEndRegistered) return
-  touchEndRegistered = true
-  _creatorUI.registerTouchEndEvent(onTouchEnd)
+// The scene-level pointer dispatch rides the tree emitter (TREE_EVENT_SCENE_TOUCH_START / SCENE_CLICK):
+// installed once, on the first listener.
+let registered = false
+const register = (): void => {
+  if (registered) return
+  registered = true
+  ensureEmitter()
+  setSceneTouchHandlers(onTouchStart, onTouchEnd)
 }
+export const registerTouchStartEvent = register
+export const registerTouchEndEvent = register

package/src/host.d.ts

@@ -1,6 +1,5 @@
 // JS-runtime globals provided by the host engine (web viewer / desktop / iOS), NOT by the SDK.
-// Declared only so SDK and user code type-check — never bundled or injected. Mirrors
-// packages/projects/src/global.d.ts.
+// Declared only so SDK and user code type-check — never bundled or injected.
 
 declare global {
   function setTimeout(handler: (...args: any[]) => void, timeout?: number): number
@@ -57,7 +56,7 @@ declare global {
    *  `Style<typeof myButton>`) is what you'd pass to `el.style(...)` — for typing reusable style
    *  presets. Deliberately no `Partial<>` wrapper: every style prop is already optional, and
    *  Partial over ClassStyles' `$`-index signature adds `| undefined`, breaking assignability back
-   *  into `.style(...)`. Round-trip guarded by sdk/tests/ui-types.test.ts. */
+   *  into `.style(...)`. Round-trip guarded by sdk/tests/ui/types.test.ts. */
   type Style<T> = T extends { style: (s: infer S) => any } ? S : never
 }
 

package/src/inject.editor.ts

@@ -0,0 +1,7 @@
+// The SECOND inject module of an editor bundle (a compile with `editor: true` — bundler.ts adds it
+// after inject.ts): what a scene editor's in-world half may name and an app may not. A shipped
+// bundle is compiled without it, so nothing here can reach one.
+//
+// Same rule as inject.ts: the only file that exports these names.
+
+export { sceneEditor as __sceneEditor, type SceneEditorApi } from "./scene/editor"

package/src/inject.ts

@@ -52,7 +52,7 @@ export { Bus, REVERB_PRESETS, type ReverbPreset, type ReverbParams, type EchoPar
 export { audio, type PlaySoundOptions, type SpatialOptions, type Rolloff, type AudioStats } from "./audio/audio"
 export { openFilePicker, files, type FileData } from "./runtime/files"
 export { share } from "./runtime/share"
-export { ClickEvent, TouchStartEvent, LongPressEvent } from "./runtime/touch"
+export { ClickEvent, TouchStartEvent, LongPressEvent, MouseEnterEvent } from "./runtime/touch"
 
 // ---- 2D engine (creator-2d) ----
 export { Scene2D } from "./g2/Scene2D"
@@ -114,7 +114,7 @@ export {
 // The Presentable navigation contract (docs/navigation-presentable-plan.md). `Presentable` is
 // interface + runtime companion (declaration merging): `Presentable.current` = what's on screen.
 export { Presentable } from "./ui/UI"
-export type { PresentOptions, Transition, TransitionName, TransitionSpec, TransitionTransform } from "./ui/UI"
+export type { DismissOptions, PresentOptions, Transition, TransitionName, TransitionPose, TransitionSpec } from "./ui/UI"
 // The base node type + the union a container accepts as children — documented as the signature of
 // UIColumn/UIRow/append/etc., so they must be global (type-only; erased at runtime).
 export type { UINode, UINodeChild } from "./ui/UINode"
@@ -135,26 +135,23 @@ export { type TweenMeta } from "./animate/tween/spec"
 export { type EasingInput } from "./animate/tween/easing"
 export { easeIn, easeOut, easeInOut } from "./animate/easings"
 
-// ---- plugins (optional, host-provided capabilities — typed NativeView/service wrappers, see src/plugins/) ----
-export { QRScanner } from "./plugins/qr"
-export { CameraView, type CameraFacing } from "./plugins/camera"
-export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from "./plugins/geolocation"
+// ---- plugins (optional, host-provided capabilities — typed NativeView/service wrappers). The first-party
+// ones are VENDORED from the plugin repo (src/plugins/gen, `bun run vendor:plugins`); oauth / service are the SDK's. ----
+export { QRScanner } from "./plugins/gen/qr-scanner/sdk/qr-scanner"
+export { CameraView, type CameraFacing } from "./plugins/gen/camera/sdk/camera"
+export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from "./plugins/gen/geolocation/sdk/geolocation"
 export {
   MapView, type MapOptions, type MapStyle, type MapStyleName, type MapCamera, type MapTap, type LngLat, type CameraMove, type FitOptions,
   type MapPaddingValues, type MarkerItem, type MarkerTap, type MarkerLayer, type MarkerLayerOptions,
   type LineLayer, type LineLayerOptions, type UserLocationOptions,
-} from "./plugins/map"
-export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/push"
+} from "./plugins/gen/map/sdk/map"
+export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/gen/push/sdk/push"
 export { OAuth, type OAuthCredential, type OAuthProviderName } from "./plugins/oauth"
 export { Service } from "./plugins/service"
 
 // ---- scenes as data (.scene.ts files — see src/scene/defineScene.ts) ----
-export { defineScene, use, ref, make, SceneHandle, applyEditorPose as __applyEditorPose } from "./scene/defineScene"
-export {
-  defineMaterial, MaterialHandle,
-  // editor-harness helpers (the scene editor's live material paths — not app API)
-  assignMaterialDef as __assignMaterialDef, applyMaterialParam as __applyMaterialParam,
-} from "./scene/material"
+export { defineScene, use, ref, make, SceneHandle } from "./scene/defineScene"
+export { defineMaterial, MaterialHandle } from "./scene/material"
 export type { MaterialData, MaterialParamValue, ShaderMaterialDef, LitMaterialDef, UnlitMaterialDef } from "./scene/material"
 export type { SceneDef, SceneNodeDef, MeshDef, LightDef, MaterialDef, CameraNodeDef, AspectEntry, MakeEntry, LoadedScene, SceneInstance } from "./scene/defineScene"
 export { CameraPlace } from "./gl/CameraPlace"
@@ -164,14 +161,14 @@ export type { LevelSpot, LevelBuild, LevelCollider, LevelLineOptions, LevelGridO
 export type { FieldMeta } from "./core/fields"
 // Editor-only line drawing from generator rebuild() / make() factories / tool hooks — drawn by the
 // scene editor's viewport overlay, a no-op everywhere else (see src/scene/gizmos.ts).
-export { Gizmos, GizmoBuffer as __GizmoBuffer, withGizmoScope as __withGizmoScope } from "./scene/gizmos"
+export { Gizmos } from "./scene/gizmos"
 export type { GizmoStyle, GizmoAnchor } from "./scene/gizmos"
 
 // ---- no-code scenario aspects (attachable in the scene editor — see src/gl/scenarios.ts) ----
 export { MoveTo, FollowPath, Spin, LookAt, PlayAnimation } from "./gl/scenarios"
 
 // ---- editor plugins (called from `*.editor.ts` files — editor bundles only; DCE'd from apps) ----
-export { registerEditorWindow, registerEditorTool, __editorPlugins } from "./scene/editorPlugins"
+export { registerEditorWindow, registerEditorTool } from "./scene/editorPlugins"
 export type { EditorApi, EditorRayHit, EditorToolHooks, EditorWindowFn } from "./scene/editorPlugins"
 
 // ---- 3D engine (creator-gl) ----

package/src/net/core.ts

@@ -43,6 +43,8 @@ export type NetEvents = {
 }
 
 export type NetLaunch = { role: "server" | "client"; address: string; port: number; maxClients: number }
+/** Link statistics (`player.rtt` / `player.loss` read them): the bridge's `NetStats`. */
+export type NetStats = { rtt: number; loss: number; sentKbps: number; receivedKbps: number }
 
 export const CH_RELIABLE = 0
 export const CH_UNRELIABLE = 1
@@ -80,8 +82,8 @@ export class NetPlayer {
 
   get isMe(): boolean { return state.me === this }
   /** Round trip to this player in ms (server side) or to the server (our own player on a client). */
-  get rtt(): number { return infoOf(this)[1] }
-  get loss(): number { return infoOf(this)[2] }
+  get rtt(): number { return infoOf(this)?.rtt ?? 0 }
+  get loss(): number { return infoOf(this)?.loss ?? 0 }
 
   /** Server → this player. */
   send<T>(msg: NetMessage<T>, data: T): void {
@@ -162,10 +164,9 @@ export const emit = (event: keyof NetEvents, ...args: any[]): void => {
   for (const fn of list.slice()) fn(...args)
 }
 
-const EMPTY_INFO = new Float32Array(5)
-const infoOf = (p: NetPlayer): Float32Array => {
+const infoOf = (p: NetPlayer): NetStats | null => {
   const b = bridge()
-  if (!b || p._slot === LOCAL_SLOT && state.role !== "client") return EMPTY_INFO
+  if (!b || p._slot === LOCAL_SLOT && state.role !== "client") return null
   return b.clientInfo(p._slot)
 }
 

package/src/net/index.ts

@@ -30,7 +30,7 @@ class NetImpl {
   get players(): readonly NetPlayer[] { if (state.role !== "server") ensureMe(); return state.players }
   player(id: number): NetPlayer | undefined { return state.players.find((p) => p.id === id) }
   /** Our round trip to the server (client), 0 otherwise. */
-  get rtt(): number { return state.role === "client" ? (bridge()?.clientInfo(0)[1] ?? 0) : 0 }
+  get rtt(): number { return state.role === "client" ? (bridge()?.clientInfo(0)?.rtt ?? 0) : 0 }
   /** The simulation tick — one per fixed step (`updateFixed`). The server's is THE tick; a client
    *  runs a few ticks ahead so its inputs arrive in time. */
   get tick(): number { return currentTick() }

package/src/net/replication.ts

@@ -407,7 +407,7 @@ const sendSnapshots = (): void => {
 
 // ---- client: snapshots in, inputs out, the clock, interpolation, correction ----------------------------
 
-const rttTicks = (): number => (bridge()?.clientInfo(0)[1] ?? 0) / TICK_MS
+const rttTicks = (): number => (bridge()?.clientInfo(0)?.rtt ?? 0) / TICK_MS
 
 const onClientBinary = (channel: number, data: ArrayBuffer): void => {
   if (data.byteLength < 12) return

package/src/plugin.ts

@@ -0,0 +1,191 @@
+// `lecodes-sdk/plugin` — the one entry a PLUGIN imports the SDK through (docs/plans/plugins-plan.md).
+// Two readers:
+//   - a plugin's `contract.d.ts`: the channel markers and the precise value types the generator maps
+//     to Swift / Kotlin;
+//   - its `sdk/` wrapper, generated (`<id>.gen.ts`) and hand-written (`<id>.ts`): the two channel
+//     bases and the few SDK internals a wrapper needs.
+//
+// A contract describes the WIRE of one channel, never the app-facing API: three interfaces per
+// channel — the methods (it extends a marker), the params, the events.
+
+import { File as HostFile } from "./runtime/fetch"
+import { ServiceClient } from "./runtime/service"
+import { NativeView, NativeViewElement } from "./ui/NativeView"
+import { _navEpoch } from "./ui/presentable"
+import { _requestCameraPermission } from "./plugins/permission"
+
+export type { PresentOptions } from "./ui/presentable"
+export type { NativeView } from "./ui/NativeView"
+export type { FetchResponse } from "./runtime/fetch"
+
+// ---- the contract's vocabulary ---------------------------------------------------------------------
+
+/** Signed 32-bit integer on the wire. */
+export type i32 = number
+/** Double on the wire — also every integer that can leave 32 bits (a millisecond time stamp). */
+export type f64 = number
+
+/** Bytes that STAY in the host's buffer table: the native half hands over its bytes + a name, the
+ *  app gets the SDK's `File` handle (a texture source, a `FormData` value, a share) and the bytes
+ *  never enter the JS heap. For bytes the app must read itself, a contract says `Uint8Array`. */
+export type File = HostFile
+
+/** Any JSON value, opaque to the generator (GeoJSON, a developer's own payload): it crosses as is
+ *  and the native half receives the platform's untyped value. */
+export type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
+
+declare const channel: unique symbol
+
+/** Marks a contract interface as a NativeView channel. `Name` is what the halves register under
+ *  (`registerView(name)`); `Params` is what a factory receives; `Events` maps an event's name to
+ *  its payload (`void` = no payload). */
+export interface View<Name extends string, Params extends object = {}, Events extends object = {}> {
+  readonly [channel]?: { kind: "view", name: Name, params: Params, events: Events }
+}
+
+/** Marks a contract interface as a headless Service channel — see {@link View}. */
+export interface Service<Name extends string, Params extends object = {}, Events extends object = {}> {
+  readonly [channel]?: { kind: "service", name: Name, params: Params, events: Events }
+}
+
+// ---- the wrapper's bases ---------------------------------------------------------------------------
+
+/** A listener of the event `K`: no argument for a `void` payload. */
+export type Listener<Events, K extends keyof Events> = Events[K] extends void ? () => void : (payload: Events[K]) => void
+
+/** A method the host's half is too old for (`@since`): refused HERE, by what it needs, before the
+ *  half is asked. `version` = the half's contract version (0 = the host has none: the channel's own
+ *  "not supported" speaks then). */
+const tooOld = (iface: string, name: string, method: string, since: number, version: number): Error | null =>
+  since > 1 && version > 0 && version < since
+    ? new Error(`${iface}.${method} needs the "${name}" plugin at contract version ${since} — this host's is ${version}`)
+    : null
+
+/** An optional argument the caller left out is ABSENT on the wire, not a null in its place. */
+const present = (args: any[]): any[] => {
+  let n = args.length
+  while (n > 0 && args[n - 1] === undefined) n--
+  return n === args.length ? args : args.slice(0, n)
+}
+
+/** What an event's payload is read with when it is not on the wire what it is for the app (it
+ *  holds a File): by the event's name. */
+export type EventReaders = { [event: string]: (wire: any) => any }
+
+/** The listeners of the events that have a reader: the app's callback → the one that reads first,
+ *  so `off` finds what `on` registered. */
+class Readers {
+  private readonly wrapped = new Map<string, Map<Function, (data?: any) => void>>()
+  private readonly readers: EventReaders | undefined
+  constructor(readers: EventReaders | undefined) { this.readers = readers }
+
+  on(event: string, callback: (data?: any) => void): (data?: any) => void {
+    const read = this.readers?.[event]
+    if (!read) return callback
+    let byCallback = this.wrapped.get(event)
+    if (!byCallback) this.wrapped.set(event, byCallback = new Map())
+    let listener = byCallback.get(callback)
+    if (!listener) byCallback.set(callback, listener = (wire?: any) => callback(read(wire)))
+    return listener
+  }
+  off(event: string, callback: (data?: any) => void): (data?: any) => void {
+    const byCallback = this.wrapped.get(event)
+    const listener = byCallback?.get(callback)
+    if (!listener) return callback
+    byCallback!.delete(callback)
+    return listener
+  }
+}
+
+/** The element of a view plugin: a `NativeView` whose events are the contract's. Generated wrappers
+ *  extend it (`<Name>Base`); a hand-written one extends that, or this when its API is not the wire's. */
+export class ViewChannel<Events extends object = {}> extends NativeViewElement {
+  /** @internal The contract interface's name, for messages. */
+  readonly _iface: string
+  private readonly _readers: Readers
+
+  constructor(iface: string, name: string, params: object, readers?: EventReaders) {
+    super(name, params)
+    this._iface = iface
+    this._readers = new Readers(readers)
+  }
+
+  /** Whether this host registered a view under `name` — at contract version `since` or later, when
+   *  one is given (a method's `@since`). */
+  static supports(name: string, since = 1): boolean { return since <= 1 ? NativeView.isSupported(name) : NativeView.version(name) >= since }
+
+  override on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.on(event, this._readers.on(event, callback as (data?: any) => void))
+  }
+  override off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.off(event, this._readers.off(event, callback as (data?: any) => void))
+  }
+
+  /** @internal One call over the wire — what the generated functions are made of. */
+  _call(method: string, args: any[], since = 1): Promise<any> {
+    const old = since > 1 ? tooOld(this._iface, this.viewName, method, since, NativeView.version(this.viewName)) : null
+    return old ? Promise.reject(old) : this._channelSend(method, present(args))
+  }
+}
+
+/** The client of a service plugin: a session that opens on the first call, with the contract's
+ *  events. The service twin of {@link ViewChannel}. */
+export class ServiceChannel<Events extends object = {}> extends ServiceClient {
+  /** @internal */
+  readonly _iface: string
+  private readonly _readers: Readers
+
+  constructor(iface: string, name: string, params: object = {}, readers?: EventReaders) {
+    super(name, params)
+    this._iface = iface
+    this._readers = new Readers(readers)
+  }
+
+  /** Whether this host registered a service under `name` — at contract version `since` or later,
+   *  when one is given (a method's `@since`). */
+  static supports(name: string, since = 1): boolean { return since <= 1 ? ServiceClient.isSupported(name) : ServiceClient.version(name) >= since }
+
+  override on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.on(event, this._readers.on(event, callback as (data?: any) => void))
+  }
+  override off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.off(event, this._readers.off(event, callback as (data?: any) => void))
+  }
+
+  /** @internal */
+  _call(method: string, args: any[], since = 1): Promise<any> {
+    const old = since > 1 ? tooOld(this._iface, this.serviceName, method, since, ServiceClient.version(this.serviceName)) : null
+    return old ? Promise.reject(old) : this._channelSend(method, present(args))
+  }
+}
+
+// ---- what a wrapper reads off the wire -------------------------------------------------------------
+
+/** @internal A `File` of the contract as it crosses: the host buffer's id, the name, the size. */
+export const _toFile = (wire: { systemId: number, name: string, size: number }): File =>
+  new HostFile(wire.systemId, wire.name, wire.size)
+
+/** @internal …and the other way: a File the app hands a half. The bytes stay where they are — the
+ *  half reads them out of the host's buffer table. */
+export const _fromFile = (file: File): { systemId: number, name: string, size: number } =>
+  ({ systemId: file._h.id, name: file.name, size: file.size })
+
+// ---- for the hand-written part ---------------------------------------------------------------------
+
+/** The text of a host buffer — what a bundled `asset()` is in a shell compile (`"id:N"`): the host
+ *  already holds the bytes. Empty when there is no such buffer. */
+export const bufferText = (systemId: number): string => _creatorFetch.toText(systemId)
+
+/** Prepare-then-present for a view that needs the camera: fail before any prompt on a host without
+ *  the view, ask for the permission while the current destination stays visible, give up when
+ *  another navigation superseded this one. Resolves when the view may open. */
+export const prepareCamera = async (view: ViewChannel<any>): Promise<void> => {
+  if (!NativeView.isSupported(view.viewName)) {
+    throw new Error(`${view._iface} isn't available on this host — it needs a registered "${view.viewName}" view.`)
+  }
+  const epoch = _navEpoch()
+  await _requestCameraPermission()
+  if (_navEpoch() !== epoch) {
+    throw new Error(`${view._iface}.open() superseded: another destination was opened while preparing`)
+  }
+}

package/src/plugins/gen/camera/contract.d.ts

@@ -0,0 +1,27 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// camera — a live camera preview with still capture.
+// The contract of the WIRE: what the app-facing `CameraView` (sdk/) and the halves (ios/, android/,
+// web/) agree on. The generator reads this file; nothing else describes the channel.
+
+import type { File, View } from "../../../plugin"
+
+export type Facing = "front" | "back"
+
+export interface CameraParams {
+  /** Default "back". */
+  facingMode?: Facing
+}
+
+export interface CameraEvents {
+  /** The preview could not start or stopped (no camera, the stream was refused). */
+  error: { message: string }
+}
+
+export interface CameraView extends View<"camera", CameraParams, CameraEvents> {
+  /** Capture a still frame as a JPEG.
+   *  @rejects failed */
+  takePhoto(): Promise<File>
+  /** Switch the camera while the preview is live. */
+  setFacingMode(mode: Facing): Promise<void>
+}

package/src/plugins/gen/camera/sdk/camera.gen.ts

@@ -0,0 +1,46 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/sdk/camera.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// camera: the view "camera", contract version 1.
+
+import { ViewChannel, _toFile, type File } from "../../../../plugin"
+import type { CameraEvents, CameraParams, Facing } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "camera"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Capture a still frame as a JPEG.
+ *  Rejects with "failed". */
+export const takePhoto = (view: ViewChannel<CameraEvents>): Promise<File> =>
+  view._call("takePhoto", []).then((w: any) => _toFile(w))
+
+/** Switch the camera while the preview is live. */
+export const setFacingMode = (view: ViewChannel<CameraEvents>, mode: Facing): Promise<void> =>
+  view._call("setFacingMode", [mode])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "takePhoto" | "setFacingMode"
+
+/** Whether this host has the view "camera" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ViewChannel.supports(NAME)   // every method is of version 1
+
+// ---- the element ----------------------------------------------------------------------------------
+
+/** The view "camera" with the wire's methods as its own. */
+export class CameraViewBase extends ViewChannel<CameraEvents> {
+  constructor(params: CameraParams = {}) { super("CameraView", NAME, params) }
+
+  /** Capture a still frame as a JPEG.
+   *  Rejects with "failed". */
+  takePhoto(): Promise<File> { return takePhoto(this) }
+  /** Switch the camera while the preview is live. */
+  setFacingMode(mode: Facing): Promise<void> { return setFacingMode(this, mode) }
+}

package/src/plugins/gen/camera/sdk/camera.ts

@@ -0,0 +1,57 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/sdk/camera.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// CameraView — the device camera (a live preview + still capture) as a view the app opens
+// fullscreen (`await camera.open()`), pushes (`Router.push(camera)`) or embeds among a screen's
+// children. `takePhoto()` returns a `File`: a texture source, a `FormData` value, a share.
+//
+// Hand-written over the generated wire for ONE reason: the permission is asked BEFORE the view is
+// presented, while the current destination stays visible.
+
+import { prepareCamera, type File, type NativeView, type PresentOptions } from "../../../../plugin"
+import { CameraViewBase, NAME } from "./camera.gen"
+import type { Facing } from "../contract"
+
+export type CameraFacing = Facing
+
+export interface CameraView extends NativeView {
+  /** Request the camera permission, then present the preview. The current destination stays
+   *  visible until the camera is ready; rejects if the permission is denied, the host has no
+   *  camera, or another navigation superseded this one. */
+  open(options?: PresentOptions): Promise<void>
+  /** Capture a still frame as an image `File` (host-encoded). */
+  takePhoto(): Promise<File>
+  /** Switch between the front and the back camera while the preview is live. */
+  setFacingMode(facingMode: CameraFacing): Promise<void>
+}
+
+class CameraViewElement extends CameraViewBase {
+  constructor(options: { facingMode?: CameraFacing } = {}) {
+    super({ facingMode: options.facingMode ?? "back" })
+  }
+
+  /** @internal prepare-then-present (see Presentable._prepare). */
+  _prepare(): Promise<void> { return prepareCamera(this) }
+
+  override async open(options?: PresentOptions): Promise<void> {
+    await this._prepare()
+    super.open(options)
+  }
+}
+
+/**
+ * Create a camera view (default: the back camera). `CameraView.isSupported` reports whether this
+ * host has the capability — check it before offering the feature.
+ */
+// PURE IIFE so an app that never uses the camera tree-shakes the whole plugin away.
+export const CameraView: {
+  (options?: { facingMode?: CameraFacing }): CameraView
+  /** Whether this host registered a "camera" view. */
+  readonly isSupported: boolean
+} = /*#__PURE__*/ (() => {
+  const factory = (options?: { facingMode?: CameraFacing }): CameraView =>
+    new CameraViewElement(options) as unknown as CameraView
+  Object.defineProperty(factory, "isSupported", {
+    get: (): boolean => CameraViewBase.supports(NAME),
+  })
+  return factory as any
+})()

package/src/plugins/gen/geolocation/contract.d.ts

@@ -0,0 +1,50 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/geolocation/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// geolocation — the device position.
+// The wire has ONE watch per session (startWatch / stopWatch + the `position` event); the
+// app-facing `Geolocation.watch(callback)` fans it out to its subscribers in sdk/.
+//
+// A session opens without a prompt. The OS permission prompt belongs to the first call that needs
+// the position.
+
+import type { Service, f64 } from "../../../plugin"
+
+export interface GeoOptions {
+  /** Prefer the precise (GPS) provider — slower first fix, more battery. Default false. */
+  highAccuracy?: boolean
+  /** getCurrent only: reject with "timeout" when no fix arrives in this many ms. */
+  timeout?: f64
+}
+
+export interface GeoPosition {
+  latitude: f64
+  longitude: f64
+  /** Horizontal accuracy radius, meters. */
+  accuracy: f64
+  /** Meters above sea level; null when the provider does not know. */
+  altitude: f64 | null
+  /** Direction of travel, degrees clockwise from north; null when stationary or unknown. */
+  heading: f64 | null
+  /** Ground speed, m/s; null when unknown. */
+  speed: f64 | null
+  /** When the fix was taken, ms since the epoch. */
+  timestamp: f64
+}
+
+export interface GeolocationParams {}
+
+export interface GeolocationEvents {
+  /** A fix of the live watch. */
+  position: GeoPosition
+}
+
+export interface Geolocation extends Service<"geolocation", GeolocationParams, GeolocationEvents> {
+  /** One fix.
+   *  @rejects denied unavailable timeout */
+  getCurrent(options?: GeoOptions): Promise<GeoPosition>
+  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+   *  A second call while watching resolves at once and keeps the first call's options.
+   *  @rejects denied unavailable */
+  startWatch(options?: GeoOptions): Promise<void>
+  stopWatch(): Promise<void>
+}

package/src/plugins/gen/geolocation/sdk/geolocation.gen.ts

@@ -0,0 +1,54 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/geolocation/sdk/geolocation.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// geolocation: the service "geolocation", contract version 1.
+
+import { ServiceChannel } from "../../../../plugin"
+import type { GeoOptions, GeoPosition, GeolocationEvents, GeolocationParams } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "geolocation"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** One fix.
+ *  Rejects with "denied" / "unavailable" / "timeout". */
+export const getCurrent = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<GeoPosition> =>
+  service._call("getCurrent", [options])
+
+/** Start the session's watch; resolves once it is live (permission granted, provider started).
+ *  A second call while watching resolves at once and keeps the first call's options.
+ *  Rejects with "denied" / "unavailable". */
+export const startWatch = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<void> =>
+  service._call("startWatch", [options])
+
+export const stopWatch = (service: ServiceChannel<GeolocationEvents>): Promise<void> =>
+  service._call("stopWatch", [])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "getCurrent" | "startWatch" | "stopWatch"
+
+/** Whether this host has the service "geolocation" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** The service "geolocation" with the wire's methods as its own. */
+export class GeolocationBase extends ServiceChannel<GeolocationEvents> {
+  constructor(params: GeolocationParams = {}) { super("Geolocation", NAME, params) }
+
+  /** One fix.
+   *  Rejects with "denied" / "unavailable" / "timeout". */
+  getCurrent(options?: GeoOptions): Promise<GeoPosition> { return getCurrent(this, options) }
+  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+   *  A second call while watching resolves at once and keeps the first call's options.
+   *  Rejects with "denied" / "unavailable". */
+  startWatch(options?: GeoOptions): Promise<void> { return startWatch(this, options) }
+  stopWatch(): Promise<void> { return stopWatch(this) }
+}