lecodes-sdk 2.1.1 → 2.2.1

package/dist/global.d.ts

@@ -159,6 +159,7 @@ declare global {
   const __rpc: typeof SDK.__rpc
   const __serverOnly: typeof SDK.__serverOnly
   const __uiMap: typeof SDK.__uiMap
+  const action: typeof SDK.action
   const animate: typeof SDK.animate
   const app: typeof SDK.app
   const audio: typeof SDK.audio
@@ -168,6 +169,7 @@ declare global {
   const computed: typeof SDK.computed
   const cubicBezier: typeof SDK.cubicBezier
   const curve: typeof SDK.curve
+  const dataOf: typeof SDK.dataOf
   const date: typeof SDK.date
   const defineMaterial: typeof SDK.defineMaterial
   const defineScene: typeof SDK.defineScene
@@ -182,6 +184,7 @@ declare global {
   const easeOut: typeof SDK.easeOut
   const effect: typeof SDK.effect
   const encodeCells: typeof SDK.encodeCells
+  const failureOf: typeof SDK.failureOf
   const fetch: typeof SDK.fetch
   const fetchLocal: typeof SDK.fetchLocal
   const files: typeof SDK.files
@@ -199,6 +202,7 @@ declare global {
   const registerEditorWindow: typeof SDK.registerEditorWindow
   const registerFont: typeof SDK.registerFont
   const resolveTire: typeof SDK.resolveTire
+  const resource: typeof SDK.resource
   const rot180: typeof SDK.rot180
   const rot270: typeof SDK.rot270
   const rot90: typeof SDK.rot90
@@ -212,6 +216,7 @@ declare global {
   const toast: typeof SDK.toast
   const use: typeof SDK.use
   type ARScene<T extends ARMode = "default"> = SDK.ARScene<T>
+  type Action<A extends unknown[], R> = SDK.Action<A, R>
   type ActiveClip = SDK.ActiveClip
   type AeroConfig = SDK.AeroConfig
   type AnimateOptions<T extends AnimateValue> = SDK.AnimateOptions<T>
@@ -288,6 +293,7 @@ declare global {
   type EditorWindowFn = SDK.EditorWindowFn
   type EngineConfig = SDK.EngineConfig
   type EventMap = SDK.EventMap
+  type Failure = SDK.Failure
   type Feet = SDK.Feet
   type FeetOptions = SDK.FeetOptions
   type FetchResponse = SDK.FetchResponse
@@ -337,6 +343,7 @@ declare global {
   type LineLayerOptions = SDK.LineLayerOptions
   type LitMaterialDef = SDK.LitMaterialDef
   type LngLat = SDK.LngLat
+  type Loaded<T> = SDK.Loaded<T>
   type LoadedScene<D extends SceneDef> = SDK.LoadedScene<D>
   type LoadedScene2d<D extends Scene2dDef> = SDK.LoadedScene2d<D>
   type Locale = SDK.Locale
@@ -436,6 +443,7 @@ declare global {
   type RagdollPart = SDK.RagdollPart
   type Ray = SDK.Ray
   type Replicated = SDK.Replicated
+  type Resource<T> = SDK.Resource<T>
   type ReverbParams = SDK.ReverbParams
   type ReverbPreset = SDK.ReverbPreset
   type RibbonOptions = SDK.RibbonOptions

package/dist/types/core/signals.d.ts

@@ -4,6 +4,12 @@ export interface Signal<T> {
     value: T;
     /** Read without subscribing the current effect/computed. */
     peek(): T;
+    /**
+     * Kept on the device under `key`: what the last run left there replaces the initial value (when
+     * it is there and reads as JSON), and every write is saved. JSON values only — a date, a class
+     * instance or a function does not survive the round trip. `signal<Line[]>([]).stored("cart")`.
+     */
+    stored(key: string): Signal<T>;
 }
 export interface Computed<T> {
     readonly value: T;

package/dist/types/inject.d.ts

@@ -22,6 +22,7 @@ export { Input, InputChannel, type InputKeyEvent, type InputGamepadEvent, type I
 export { WebSocket } from "./runtime/net";
 export { Net, NetPlayer, Replicated, NetEntity, type NetMessage, type NetRole, type NetStatus, type NetEvents, type NetLaunch, type NetInput, type NetKind, type NetTransform, type NetCorrection } from "./net";
 export { __rpc, __channel, __serverOnly, RpcError } from "./runtime/rpc";
+export { resource, action, dataOf, failureOf, type Loaded, type Failure, type Resource, type Action } from "./runtime/resource";
 export type { ChannelSubscription } from "./server/channel";
 export type { StoredFile, StoredImage } from "./server/files/models";
 export { AudioPlayer, VideoPlayer } from "./runtime/media";

package/dist/types/runtime/resource.d.ts

@@ -0,0 +1,49 @@
+import { type Computed } from "../core/signals";
+/** Why a call failed: the server's refusal in its words — or `offline`, the request never reached
+ *  it (then `message` is the transport's note, not something to show; say it in your own words). */
+export type Failure = {
+    readonly message: string;
+    readonly offline: boolean;
+};
+/** What was asked of the server, at any moment: one value a screen draws in its three states. */
+export type Loaded<T> = {
+    readonly state: "loading";
+} | {
+    readonly state: "ready";
+    readonly data: T;
+} | ({
+    readonly state: "failed";
+} & Failure);
+/** The data once it is there; `otherwise` until then. */
+export declare const dataOf: <T>(loaded: Loaded<T>, otherwise: T) => T;
+/** The failure, or null while there is none. */
+export declare const failureOf: <T>(loaded: Loaded<T>) => Failure | null;
+export interface Resource<T> {
+    /** The request now — read in an effect, a computed or a binding, the screen follows it. */
+    readonly value: Loaded<T>;
+    /** Read without subscribing. */
+    peek(): Loaded<T>;
+    /** Ask again. What is shown stays until the answer. */
+    reload(): void;
+}
+/**
+ * What `load` answers, as a `Loaded` signal: asked at once, again when a signal `load` read changes
+ * and on `reload()`. An answer that arrives after a newer request was made is dropped. While the
+ * data is asked for again, what is there stays. With `initial` — rows the bundle carries — the data
+ * is ready from the start and the server's answer replaces it; a failure then leaves it as it is,
+ * since what is shown is real.
+ */
+export declare function resource<T>(load: () => Promise<T>, options?: {
+    initial?: T;
+}): Resource<T>;
+export type Action<A extends unknown[], R> = ((...args: A) => Promise<R | null>) & {
+    /** True while a call runs; a call made meanwhile is ignored (it resolves to null). */
+    readonly busy: Computed<boolean>;
+    /** Why the last call failed; null when it did not. Cleared as a call starts. */
+    readonly error: Computed<Failure | null>;
+};
+/**
+ * Something the person does that the server must carry out. Resolves to what the server answered,
+ * or null when the call failed (then `error` says why) or was ignored while busy.
+ */
+export declare function action<A extends unknown[], R>(run: (...args: A) => Promise<R>): Action<A, R>;

package/dist/types/server/db/marci/query.d.ts

@@ -282,6 +282,10 @@ export interface Query<T extends ModelTypes, Sel = T["scalars"]> extends Promise
     }>;
     aggregate<A extends T["aggregate"]>(query: A): Op<AggregateResult<T["model"], A>> & Sub<T["name"], NoInfer<A>>;
     insert(data: T["insert"]): Op<T["id"]>;
+    /** The new row by `select`'s shape — its defaults, dates and files as stored: one call, nothing to read back. */
+    insert<S extends T["query"]>(data: T["insert"], options: {
+        select: S;
+    }): Promise<Rows<T, S>>;
     update(id: IdArg<T["id"]>, data: T["update"]): Op<void>;
     /** Applies `data` to every row the chain's `where` matches (all rows without one); resolves to the number of rows. */
     updateMany(data: T["update"]): Op<number>;

package/dist/types/server/db/types.d.ts

@@ -8,7 +8,7 @@
  */
 import type { Field, FieldMeta } from "./fields";
 import type { IdentityPublicFields, SessionPublicFields } from "../auth/models";
-import type { StoredFile, UploadedFile as File } from "../files/models";
+import type { FileWrite, StoredFile } from "../files/models";
 import type { CompareNumValue, CompareRefListValue, CompareRefValue, CompareStrValue, CompareValue, CustomSearchValue, FullTextSearch, JsonCondition, JsonPathWhere, Op, PrimitiveListUpdate, Query as MarciQuery, RefListUpdate, RefListUpdateOrdered, RefUpdate, RefUpdateStruct, Rows, Sub, UpdateNumValue, VectorSearch, WhereValue } from "./marci/query";
 export type Fields = Record<string, Field<any, any>>;
 export type Model<F extends Fields = Fields> = {
@@ -66,7 +66,7 @@ export type Scalars<S, N extends keyof S> = Pick<Row<S, N>, (ScalarKeys<FieldsOf
 export type ScalarSelect<S, N extends keyof S> = {
     [K in (ScalarKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & keyof Row<S, N>]: true;
 };
-type FieldInsert<S, Fld, M extends FieldMeta = MetaOf<Fld>> = M["kind"] extends "one" ? Nullable<M, Id<S, ModelName<S, Fld>>> : M["kind"] extends "many" | "list" ? Id<S, ModelName<S, Fld>>[] : M["kind"] extends "struct" ? Nullable<M, StructInsert<S, StructFieldsOf<Fld>>> : M["kind"] extends "file" ? Nullable<M, Arr<M, File>> : Nullable<M, Arr<M, TsOf<Fld>>>;
+type FieldInsert<S, Fld, M extends FieldMeta = MetaOf<Fld>> = M["kind"] extends "one" ? Nullable<M, Id<S, ModelName<S, Fld>>> : M["kind"] extends "many" | "list" ? Id<S, ModelName<S, Fld>>[] : M["kind"] extends "struct" ? Nullable<M, StructInsert<S, StructFieldsOf<Fld>>> : M["kind"] extends "file" ? Nullable<M, Arr<M, FileWrite>> : Nullable<M, Arr<M, TsOf<Fld>>>;
 type RequiredKeys<F extends Fields> = {
     [K in keyof F]: K extends IdKeys<F> ? never : MetaOf<F[K]>["optional"] extends true ? never : MetaOf<F[K]>["hasDefault"] extends true ? never : MetaOf<F[K]>["kind"] extends "many" | "list" ? never : MetaOf<F[K]>["kind"] extends "file" ? (MetaOf<F[K]>["array"] extends true ? never : K) : K;
 }[keyof F];
@@ -80,7 +80,7 @@ type InsertOf<S, F extends Fields> = Simplify<{
 }>;
 export type Insert<S, N extends keyof S> = InsertOf<S, FieldsOf<S[N]>>;
 type StructInsert<S, F extends Fields> = InsertOf<S, F>;
-type FieldUpdate<S, Fld, M extends FieldMeta = MetaOf<Fld>> = M["kind"] extends "one" ? Nullable<M, RefUpdate<Id<S, ModelName<S, Fld>>>> : M["kind"] extends "many" ? RefListUpdate<Id<S, ModelName<S, Fld>>> : M["kind"] extends "list" ? RefListUpdateOrdered<Id<S, ModelName<S, Fld>>> : M["kind"] extends "struct" ? RefUpdateStruct<StructInsert<S, StructFieldsOf<Fld>>, UpdateOf<S, StructFieldsOf<Fld>>> | null : M["kind"] extends "file" ? Nullable<M, Arr<M, File | StoredFile>> : M["array"] extends true ? TsOf<Fld>[] | PrimitiveListUpdate<TsOf<Fld>> : Nullable<M, TsOf<Fld> | (IsNum<M> extends true ? UpdateNumValue : never)>;
+type FieldUpdate<S, Fld, M extends FieldMeta = MetaOf<Fld>> = M["kind"] extends "one" ? Nullable<M, RefUpdate<Id<S, ModelName<S, Fld>>>> : M["kind"] extends "many" ? RefListUpdate<Id<S, ModelName<S, Fld>>> : M["kind"] extends "list" ? RefListUpdateOrdered<Id<S, ModelName<S, Fld>>> : M["kind"] extends "struct" ? RefUpdateStruct<StructInsert<S, StructFieldsOf<Fld>>, UpdateOf<S, StructFieldsOf<Fld>>> | null : M["kind"] extends "file" ? Nullable<M, Arr<M, FileWrite | StoredFile>> : M["array"] extends true ? TsOf<Fld>[] | PrimitiveListUpdate<TsOf<Fld>> : Nullable<M, TsOf<Fld> | (IsNum<M> extends true ? UpdateNumValue : never)>;
 type UpdateOf<S, F extends Fields> = {
     [K in Exclude<keyof F, IdKeys<F>>]?: FieldUpdate<S, F[K]>;
 };

package/dist/types/server/files/models.d.ts

@@ -44,6 +44,13 @@ export type UploadedFile = {
     readonly size: number;
     readonly type: string;
 };
+/** What a file field is written with. A project's own type check sees the endpoint's `File` as the
+ *  app's (global.d.ts: a name and a size — the type is read from the bytes on arrival), so the write
+ *  asks for no more; what arrives is an `UploadedFile`. */
+export type FileWrite = {
+    readonly name: string;
+    readonly size: number;
+};
 /** One `t.file()` field of the schema; `image` = it is a `t.image()`, with its rule. */
 export type FileField = {
     model: string;

package/dist/types/ui/UIInput.d.ts

@@ -29,6 +29,13 @@ type InputStyle = {
      * still work in both modes. Scrolling never dismisses the keyboard on any setting.
      */
     keyboardDismiss?: boolean;
+    /**
+     * Takes the focus when its screen opens — the keyboard is up from the first moment. For a
+     * screen made for typing: a composer, a chat, a search, a one-field form; not the first field
+     * of a long form. Once per input (a screen shown again does not take the keyboard back); one
+     * per screen. The SDK's own behaviour over `focus()`: a design tool shows the screen as it opens.
+     */
+    autofocus?: boolean;
     /** Hard cap on the text length — enforced by the host while typing/pasting. */
     maxLength?: number;
     /** Auto-capitalization hint; omitted = platform default. */

package/dist/types/ui/UIVirtualizedList.d.ts

@@ -7,6 +7,11 @@ export type UIVirtualizedListStyle = DrawableStyle & ElementStyle & {
     keyboardDismissMode?: "interactive" | "scroll" | "none";
 };
 export interface VListConfig<T> {
+    /** The rows, read reactively: the list follows the signals this reads, the way a container's
+     *  function children do. Rows are told apart by `keyOf`; a row whose item is another object
+     *  re-renders. Appended rows and rows added at the start are told from a rewrite (a chat at
+     *  its bottom follows what is appended; older history above moves nothing). */
+    data: () => T[];
     /** Stable unique key of an item. */
     keyOf: (item: T) => string;
     /** Subtree factory — called when the item enters the window; the subtree lives until it
@@ -23,20 +28,9 @@ export interface VListConfig<T> {
     inverted?: boolean;
 }
 /** A windowed (virtualized) list: only the items near the viewport are mounted — for long feeds
- *  and chats. Items are keyed; feed it via `setData`/`append`/`prepend`. */
+ *  and chats. Fed by `data`, a function over signals. */
 export interface UIVirtualizedList<T = unknown> extends UIElementBase<UIVirtualizedListStyle> {
     readonly type: "vlist";
-    /** Replace the data wholesale — vanished keys are unmounted by the window sync. */
-    setData(items: T[]): this;
-    /** Append items to the end (auto-scrolls when `inverted` and resting at the bottom). */
-    append(...items: T[]): this;
-    /** Insert at the start WITHOUT a scroll jump (the runtime compensates the offset). */
-    prepend(...items: T[]): this;
-    /** Update items with the same keys: mounted ones re-render; the cached height persists until
-     *  re-measured. */
-    update(...items: T[]): this;
-    /** Remove items by key. */
-    removeByKey(...keys: string[]): this;
     /** Number of data items (mounted or not). */
     readonly itemCount: number;
     /** The data item under `key`, if any. */
@@ -62,6 +56,7 @@ export declare class VListElement<T> extends Element<"vlist"> implements UIVirtu
     private readonly erl;
     private readonly strl;
     private _refreshCallback?;
+    private keys;
     private items;
     private mounted;
     private keyOf;
@@ -74,12 +69,10 @@ export declare class VListElement<T> extends Element<"vlist"> implements UIVirtu
     private _inited;
     constructor(config: VListConfig<T>);
     private _ensure;
-    private register;
-    setData(items: T[]): this;
-    append(...items: T[]): this;
-    prepend(...items: T[]): this;
-    update(...items: T[]): this;
-    removeByKey(...keys: string[]): this;
+    /** The data as it is now against what the runtime holds: rows added at the end or at the start
+     *  are inserts (the runtime anchors the scroll: a chat follows an append, history above moves
+     *  nothing), rows gone are removals, anything else a rewrite of the keys (measured heights stay). */
+    private _apply;
     get itemCount(): number;
     getItem(key: string): T | undefined;
     scrollTo(offset: number, animated?: boolean): void;
@@ -90,6 +83,6 @@ export declare class VListElement<T> extends Element<"vlist"> implements UIVirtu
     onEndReached(thresholdPx: number, callback: () => void): this;
     onStartReached(thresholdPx: number, callback: () => void): this;
 }
-/** Create a virtualized list from a config (`keyOf` + `render` + `estimatedHeight` required),
- *  then feed it via `setData`/`append`/`prepend`. Give it a size (`flexGrow: 1` as a screen body). */
+/** Create a virtualized list from a config (`data` + `keyOf` + `render` + `estimatedHeight`
+ *  required). Give it a size (`flexGrow: 1` as a screen body). */
 export declare function UIVirtualizedList<T>(config: VListConfig<T>): UIVirtualizedList<T>;

package/dist/types/ui/autofocus.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.1.1";
+export declare const SDK_VERSION = "2.2.1";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from