chat-layout 0.0.19 → 0.1.1

package/README.md

@@ -6,10 +6,22 @@ To install dependencies:
 bun install
 ```
 
-To run:
+To type-check:
 
 ```bash
-bun run index.ts
+bun run typecheck
+```
+
+To build distributable files:
+
+```bash
+bun run dist
+```
+
+To build example:
+
+```bash
+bun run example
 ```
 
 This project was created using `bun init` in bun v1.1.37. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/index.d.mts

@@ -0,0 +1,225 @@
+//#region src/types.d.ts
+type DynValue<C extends CanvasRenderingContext2D, T> = T extends Function ? never : T | ((context: C) => T);
+interface RendererOptions {}
+interface RenderFeedback {
+  minIdx: number;
+  maxIdx: number;
+  min: number;
+  max: number;
+}
+type Alignment = "left" | "center" | "right";
+interface Context<C extends CanvasRenderingContext2D> {
+  graphics: C;
+  remainingWidth: number;
+  alignment: Alignment;
+  reverse: boolean;
+  measureNode(node: Node<C>): Box;
+  invalidateNode(node: Node<C>): void;
+  resolveDynValue<T>(value: DynValue<C, T>): T;
+  with<T>(this: Context<C>, cb: (g: C) => T): T;
+}
+interface Box {
+  width: number;
+  height: number;
+}
+interface HitTest {
+  x: number;
+  y: number;
+  type: "click" | "auxclick" | "hover";
+}
+interface Node<C extends CanvasRenderingContext2D> {
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+  readonly flex: boolean;
+}
+//#endregion
+//#region src/nodes.d.ts
+declare abstract class Group<C extends CanvasRenderingContext2D> implements Node<C> {
+  readonly children: Node<C>[];
+  constructor(children: Node<C>[]);
+  abstract measure(ctx: Context<C>): Box;
+  abstract draw(ctx: Context<C>, x: number, y: number): boolean;
+  abstract hittest(ctx: Context<C>, test: HitTest): boolean;
+  get flex(): boolean;
+}
+declare class VStack<C extends CanvasRenderingContext2D> extends Group<C> {
+  readonly options: {
+    gap?: number;
+    alignment?: "left" | "center" | "right";
+  };
+  constructor(children: Node<C>[], options?: {
+    gap?: number;
+    alignment?: "left" | "center" | "right";
+  });
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+}
+declare class HStack<C extends CanvasRenderingContext2D> extends Group<C> {
+  readonly children: Node<C>[];
+  readonly options: {
+    reverse?: boolean;
+    gap?: number;
+  };
+  constructor(children: Node<C>[], options?: {
+    reverse?: boolean;
+    gap?: number;
+  });
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+}
+declare class Wrapper<C extends CanvasRenderingContext2D> implements Node<C> {
+  #private;
+  constructor(inner: Node<C>);
+  get inner(): Node<C>;
+  set inner(newNode: Node<C>);
+  get flex(): boolean;
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+}
+declare class PaddingBox<C extends CanvasRenderingContext2D> extends Wrapper<C> {
+  #private;
+  readonly padding: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  };
+  constructor(inner: Node<C>, padding?: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  });
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+}
+declare class AlignBox<C extends CanvasRenderingContext2D> extends Wrapper<C> {
+  #private;
+  readonly options: {
+    alignment: Alignment;
+  };
+  constructor(inner: Node<C>, options: {
+    alignment: Alignment;
+  });
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(ctx: Context<C>, test: HitTest): boolean;
+}
+declare class MultilineText<C extends CanvasRenderingContext2D> implements Node<C> {
+  #private;
+  readonly text: string;
+  readonly options: {
+    lineHeight: number;
+    font: string;
+    alignment: "left" | "center" | "right";
+    style: DynValue<C, string>;
+  };
+  constructor(text: string, options: {
+    lineHeight: number;
+    font: string;
+    alignment: "left" | "center" | "right";
+    style: DynValue<C, string>;
+  });
+  get flex(): boolean;
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(_ctx: Context<C>, _test: HitTest): boolean;
+}
+declare class Text<C extends CanvasRenderingContext2D> implements Node<C> {
+  #private;
+  readonly text: string;
+  readonly options: {
+    lineHeight: number;
+    font: string;
+    style: DynValue<C, string>;
+  };
+  constructor(text: string, options: {
+    lineHeight: number;
+    font: string;
+    style: DynValue<C, string>;
+  });
+  get flex(): boolean;
+  measure(ctx: Context<C>): Box;
+  draw(ctx: Context<C>, x: number, y: number): boolean;
+  hittest(_ctx: Context<C>, _test: HitTest): boolean;
+}
+declare class Fixed<C extends CanvasRenderingContext2D> implements Node<C> {
+  readonly width: number;
+  readonly height: number;
+  constructor(width: number, height: number);
+  get flex(): boolean;
+  measure(_ctx: Context<C>): Box;
+  draw(_ctx: Context<C>, _x: number, _y: number): boolean;
+  hittest(_ctx: Context<C>, _test: HitTest): boolean;
+}
+//#endregion
+//#region src/renderer.d.ts
+declare class BaseRenderer<C extends CanvasRenderingContext2D, O extends {} = {}> {
+  #private;
+  readonly options: RendererOptions & O;
+  graphics: C;
+  protected get context(): Context<C>;
+  constructor(graphics: C, options: RendererOptions & O);
+  invalidateNode(node: Node<C>): void;
+  measureNode(node: Node<C>, ctx?: Context<C>): Box;
+}
+declare class DebugRenderer<C extends CanvasRenderingContext2D> extends BaseRenderer<C> {
+  draw(node: Node<C>): boolean;
+  hittest(node: Node<C>, test: HitTest): boolean;
+}
+declare function memoRenderItem<C extends CanvasRenderingContext2D, T extends {}>(renderItem: (item: T) => Node<C>): ((item: T) => Node<C>) & {
+  reset: (key: T) => boolean;
+};
+declare class ListState<T extends {}> {
+  offset: number;
+  position: number;
+  items: T[];
+  unshift(...items: T[]): void;
+  unshiftAll(items: T[]): void;
+  push(...items: T[]): void;
+  pushAll(items: T[]): void;
+  reset(): void;
+  resetScroll(): void;
+  applyScroll(delta: number): void;
+}
+type DrawItem<C extends CanvasRenderingContext2D> = {
+  idx: number;
+  node: Node<C>;
+  offset: number;
+  height: number;
+};
+declare abstract class VirtualizedRenderer<C extends CanvasRenderingContext2D, T extends {}> extends BaseRenderer<C, {
+  renderItem: (item: T) => Node<C>;
+  list: ListState<T>;
+}> {
+  get position(): number;
+  set position(value: number);
+  get offset(): number;
+  set offset(value: number);
+  get items(): T[];
+  set items(value: T[]);
+  abstract render(feedback?: RenderFeedback): boolean;
+  abstract hittest(test: HitTest): boolean;
+  protected _renderDrawList(list: DrawItem<C>[], shift: number, feedback?: RenderFeedback): boolean;
+}
+declare class TimelineRenderer<C extends CanvasRenderingContext2D, T extends {}> extends VirtualizedRenderer<C, T> {
+  render(feedback?: RenderFeedback): boolean;
+  hittest(test: HitTest): boolean;
+}
+declare class ChatRenderer<C extends CanvasRenderingContext2D, T extends {}> extends VirtualizedRenderer<C, T> {
+  render(feedback?: RenderFeedback): boolean;
+  hittest(test: HitTest): boolean;
+}
+//#endregion
+//#region src/registry.d.ts
+declare function registerNodeParent<C extends CanvasRenderingContext2D>(node: Node<C>, parent: Node<C>): void;
+declare function unregisterNodeParent<C extends CanvasRenderingContext2D>(node: Node<C>): void;
+declare function getNodeParent<C extends CanvasRenderingContext2D>(node: Node<C>): Node<C> | undefined;
+//#endregion
+export { AlignBox, Alignment, BaseRenderer, Box, ChatRenderer, Context, DebugRenderer, DynValue, Fixed, Group, HStack, HitTest, ListState, MultilineText, Node, PaddingBox, RenderFeedback, RendererOptions, Text, TimelineRenderer, VStack, VirtualizedRenderer, Wrapper, getNodeParent, memoRenderItem, registerNodeParent, unregisterNodeParent };
+//# sourceMappingURL=index.d.mts.map