@vibecook/ice 0.11.0 → 0.15.0-desk.1

package/dist/types/packages/desk/src/hold/pose.d.ts

@@ -0,0 +1,152 @@
+import type { ObjectRect } from "../kinds/world";
+import { type MatLight } from "../mat/night";
+import type { CameraState } from "../nav/flight";
+/** The hand's numbers (desk.js `HOLD`). Times in ms; `margin`/`top`/`band` CSS px; `blur` CSS px; `narrow` = a phone's width. */
+export declare const HOLD: {
+    readonly inMs: 560;
+    readonly outMs: 440;
+    readonly closeLead: 0.14;
+    readonly openAt: 0.42;
+    readonly blur: 14;
+    readonly blurPhone: 10;
+    readonly dim: 0.08;
+    readonly margin: 56;
+    readonly marginPhone: 16;
+    readonly top: 56;
+    readonly topPhone: 60;
+    readonly band: 72;
+    readonly max: 3;
+    readonly zoomMin: 0.72;
+    readonly zoomMax: 3;
+    readonly narrow: 640;
+    /** The reading light by night (Q-n): the held object keeps its day light, filtered. */
+    readonly light: {
+        readonly saturate: 0.62;
+        readonly brightness: 0.82;
+    };
+    /** The cover's spring in hand (desk.js `COVER`): a palm, not a desk. */
+    readonly cover: {
+        readonly hz: 1.4;
+        readonly zeta: 0.78;
+    };
+    /** The held bar's travel (M1 morph) and its return after the landing — `travelMs` the default of a host's `hold.travelMs` (I20). */
+    readonly bar: {
+        readonly travelMs: 340;
+        readonly backMs: 200;
+    };
+};
+/**
+ * THE HAND'S RESERVES (petition I20): how far the reading fit keeps from the view's top (`top`) and from its foot (`band` — the held
+ * bar's band), CSS px. `HOLD`'s are the default; a host's chrome moves them (`deskLayer({ hold })`). A phone keeps its own top.
+ */
+export interface HoldReserves {
+    readonly top: number;
+    readonly band: number;
+}
+/**
+ * The hand as a HOST sets it (petition I20 — `deskLayer({ hold })`, read at the mount): the reserves above and below the reading fit,
+ * CSS px, and the held bar's travel (M1), ms — each `HOLD`'s when absent (`top` 56, `band` 72, `travelMs` 340). The bar is the host's:
+ * the desk publishes the travel on the selection's anchor (`HeldAnchor.travelMs`) for whichever bar draws it.
+ */
+export interface HoldOptions {
+    readonly top?: number;
+    readonly band?: number;
+    readonly travelMs?: number;
+}
+export interface HeldViewport {
+    readonly width: number;
+    readonly height: number;
+}
+/** The reading pose's target: where the open extent's centre goes on screen (CSS px), the scale there (CSS px per object unit), one page or the spread. */
+export interface ReadingTarget {
+    readonly cx: number;
+    readonly cy: number;
+    readonly s: number;
+    readonly single: boolean;
+}
+/** A phone's width (desk.js `narrow`). */
+export declare const isNarrow: (vp: HeldViewport) => boolean;
+/**
+ * The reading size (desk.js `heldTarget`): the extent fits the view inside the margins, `reserves.top` under its top and the bar's
+ * band (`reserves.band`) above its foot, never past 3× — the host's reserves (I20), `HOLD`'s by default; a phone keeps its own top
+ * and margins. `spread`: the extent is a two-page spread that may open one page at a time — on a portrait phone (W < 0.85·H) it
+ * does when one page reads at least 1.3× larger than the whole spread would; then the RIGHT page is centred (the extent's centre sits
+ * a quarter of its width left of the middle) — or, `face` → 1, the LEFT (D3t-b: the notebook reads page by page; between, the view
+ * glides). That decision is the PHONE'S, on `HOLD`'s band whatever the host reserves, so a kind that asks it alone
+ * (`readingTarget(extent, vp, true).single`) agrees with the hand; the reserves size the page it shows.
+ */
+export declare function readingTarget(extent: ObjectRect, vp: HeldViewport, spread?: boolean, face?: number, reserves?: HoldReserves): ReadingTarget;
+/** Where the extent lies on screen at rest, under the desk's camera: its centre (CSS px), the scale (the zoom) and the object's turn. */
+export interface HomePose {
+    readonly cx: number;
+    readonly cy: number;
+    readonly s: number;
+    readonly angle: number;
+}
+export declare function homePose(extent: ObjectRect, angle: number, cam: CameraState): HomePose;
+/** The user's facts on the held object (core's `HeldView`). */
+export interface HeldUser {
+    readonly zoom: number;
+    readonly panX: number;
+    readonly panY: number;
+}
+export declare const HELD_USER_REST: HeldUser;
+/** The pose between the desk and the hand: the extent's centre on screen, CSS px per unit, the turn, the carry amount. */
+export interface HeldPose {
+    readonly cx: number;
+    readonly cy: number;
+    readonly s: number;
+    readonly angle: number;
+    readonly e: number;
+}
+/** desk.js `heldPose`: position on the island curve (the caller eases `e`), size in log scale, the tilt let go. */
+export declare function heldPose(home: HomePose, target: ReadingTarget, user: HeldUser, e: number): HeldPose;
+/** The carry amount for the pickup's progress `p` (0 … 1) — the island ease; the put-down runs it backwards from where it was. */
+export declare const carryOf: (p: number) => number;
+/** The pickup's progress at a carry amount — the island ease inverted by bisection (a put-down caught mid-flight, a pinned still). */
+export declare function progressOf(e: number): number;
+/** The focus behind the hand and the light on it at a carry amount (the builder's and the oracle's ONE reading of §8's numbers). */
+export interface HeldFocus {
+    /** The radius the ONE blur is made at, CSS px (14; a phone's 10). */
+    readonly blur: number;
+    /** The desk's dim behind, by the carry (8 % at the top). */
+    readonly dim: number;
+    /** The reading light on the hand (Q-n): 1, 1 by day; toward saturate .62 · brightness .82 by night as the carry rises. */
+    readonly filter: {
+        readonly saturate: number;
+        readonly brightness: number;
+    };
+    /** The hand's own light: the desk's by day; by night the day's mixed in by the carry. */
+    readonly light: MatLight;
+}
+export declare function heldFocus(e: number, vp: HeldViewport, theme: {
+    readonly name: string;
+    readonly matLight: MatLight;
+}): HeldFocus;
+/**
+ * The held slot's CAMERA (the pose IS a camera) and the factor a kind with height must reach by rising. The object's rect centre
+ * lies `offset` (its own units, unturned) from its extent's centre; the pose turns that offset by its angle and puts the extent's
+ * centre at (pose.cx, pose.cy), so the rect's centre lands at P − R(angle)·offset·s. A flat kind's camera zooms to `pose.s` and
+ * grows nothing; an `eye` kind keeps the desk's zoom when the pose is larger (grow = pose.s / zoom ≥ 1, the rise does the rest)
+ * and zooms out with the camera when the pose is smaller (a book picked up from very close: grow 1).
+ */
+export declare function heldCamera(pose: HeldPose, rect: ObjectRect, extent: ObjectRect, deskZoom: number, eye: boolean, vp: HeldViewport): {
+    readonly cam: CameraState;
+    readonly grow: number;
+};
+/**
+ * The held object's frame ON SCREEN (what the pose seam publishes, core's `HeldScreenFrame`): the shown extent's centre and half
+ * extents, CSS px, its scale. `single`: one page alone — the right (`face` 0), the left (`face` 1), a glide between (D3t-b).
+ */
+export declare function heldFrame(pose: HeldPose, extent: ObjectRect, single: boolean, face?: number): {
+    readonly cx: number;
+    readonly cy: number;
+    readonly hx: number;
+    readonly hy: number;
+    readonly s: number;
+};
+/** The focus behind the hand: the blur radius (CSS px) and the dim at a carry amount. */
+export declare const focusOf: (e: number, vp: HeldViewport) => {
+    readonly blur: number;
+    readonly dim: number;
+};

package/dist/types/packages/desk/src/hold/shaders.d.ts

@@ -0,0 +1,9 @@
+import type { ShaderPart } from "../engine/shader";
+export interface HoldShaders {
+    readonly entry: ShaderPart;
+}
+export interface HoldShaderText {
+    readonly hold: string;
+}
+export declare const HOLD_SHADER_FILES: Record<keyof HoldShaderText, string>;
+export declare function holdShaders(t: HoldShaderText): HoldShaders;

package/dist/types/packages/desk/src/host/editor.d.ts

@@ -0,0 +1,18 @@
+import { type World } from "../../../core/src/index";
+import type { DeskEditor, TextPart } from "../kit/editor";
+/** design-007's claim marker (`@ice/dom` KEYBOARD_CLAIM_ATTR — the desk may not import dom): the keymap cedes to a focused claim. */
+export declare const KEYBOARD_CLAIM_ATTR = "data-canvas-keyboard";
+/** The editor's own marker — the one element the desk puts in screen space for text. */
+export declare const EDITOR_ATTR = "data-desk-editor";
+export interface DeskEditorOptions {
+    /** The host's container (screen space): the editor goes in it, the taps are read on it. */
+    readonly container: HTMLElement;
+    readonly world: World;
+    /** The text parts the registered objects declared, in registration order (asked at each tap — the layer fills them after the drivers). */
+    readonly parts: () => readonly TextPart[];
+    /** A session ends after this long without input, ms (1000). */
+    readonly idleMs?: number;
+    /** Ask the desk for a frame. */
+    readonly wake: () => void;
+}
+export declare function createDeskEditor(opts: DeskEditorOptions): DeskEditor;

package/dist/types/packages/desk/src/host/index.d.ts

@@ -0,0 +1,9 @@
+export { deskLayer, type DeskLayerBoot, type DeskLayerContext, type DeskLayerFactory, type DeskLayerHandle, type DeskLayerOptions, type DeskLayerPerf, type DeskLayerStatus, type DeskTrayDoor, type MatPin, type PickResult, type SelectionSource, type TrayAnchor } from "./layer";
+export type { SelectionAnchor } from "../compose/marks";
+export { surface, type Surface } from "./surface";
+export { createDeskEditor, type DeskEditorOptions, EDITOR_ATTR, KEYBOARD_CLAIM_ATTR } from "./editor";
+export { type FaceSpec, inkRaster, type InkRaster, type InkRasterOptions, PEN_FACES, penFaces } from "./ink";
+export { decodePicture } from "./picture";
+export { DEFAULT_MAT_CONFIG, GLYPH_PAD, GLYPHS, type GlyphAtlasMeta, type MatConfig, type PlateName, type RulerConfig } from "../mat/layout";
+export type { GridConfig } from "../mat/grid";
+export { type ObjectSprings, SPRINGS } from "../kit/springs";

package/dist/types/packages/desk/src/host/ink.d.ts

@@ -0,0 +1,18 @@
+import type { TextRaster } from "../kit/raster";
+import { type FaceSpec } from "../kit/text";
+export { type FaceSpec, PEN_FACES } from "../kit/text";
+/** The desk's faces with the app's files: `{ caveat: url, "caveat-bold": url, kalam: url }` → face specs. */
+export declare function penFaces(urls: Readonly<Record<string, string>>): Readonly<Record<string, FaceSpec>>;
+export interface InkRasterOptions {
+    /** The faces by name — `penFaces({ … })` for the desk's own. */
+    readonly faces: Readonly<Record<string, FaceSpec>>;
+    /** The document whose font set the faces join (the window's). */
+    readonly document?: Document;
+}
+export interface InkRaster extends TextRaster {
+    /** Load a face (once): resolves whether the browser can draw it. `metrics()` asks for this itself. */
+    load(face: string): Promise<boolean>;
+    /** Is the face loaded (and drawable)? */
+    ready(face: string): boolean;
+}
+export declare function inkRaster(opts: InkRasterOptions): InkRaster;