uzay 0.1.0

package/dist/core/atom-wrapper.d.ts

@@ -0,0 +1,38 @@
+import { type Atom, type PrimitiveAtom, type WritableAtom } from "jotai";
+import { type createStore } from "jotai/vanilla";
+export type Store = ReturnType<typeof createStore>;
+type Getter = <Value>(atom: Atom<Value>) => Value;
+type Setter = <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type AnyAtom = Atom<unknown>;
+type SetAtom<Args extends unknown[], Result> = <A extends Args>(...args: A) => Result;
+type Read<Value, SetSelf = never> = (get: Getter, options: {
+    readonly signal: AbortSignal;
+    readonly setSelf: SetSelf;
+}) => Value;
+type Write<Args extends unknown[], Result> = (get: Getter, set: Setter, ...args: Args) => Result;
+type WithInitialValue<Value> = {
+    init: Value;
+};
+export type BoundAtom<A extends AnyAtom> = A & {
+    get: () => A extends Atom<infer V> ? V : never;
+    sub: (listener: () => void) => () => void;
+} & (A extends WritableAtom<any, infer Args, infer Result> ? {
+    set: (...args: Args) => Result;
+} : {});
+export declare function createSceneAtom(store: Store): {
+    <Value, Args extends unknown[], Result>(read: Read<Value, SetAtom<Args, Result>>, write: Write<Args, Result>): BoundAtom<WritableAtom<Value, Args, Result>>;
+    <Value>(read: Read<Value>): BoundAtom<Atom<Value>>;
+    <Value, Args extends unknown[], Result>(initialValue: Value, write: Write<Args, Result>): BoundAtom<WritableAtom<Value, Args, Result> & WithInitialValue<Value>>;
+    <Value>(): BoundAtom<PrimitiveAtom<Value | undefined> & WithInitialValue<Value | undefined>>;
+    <Value>(initialValue: Value): BoundAtom<PrimitiveAtom<Value> & WithInitialValue<Value>>;
+};
+export type SceneAtomFunction = ReturnType<typeof createSceneAtom>;
+export type SceneAtom<T> = BoundAtom<Atom<T>>;
+export type AtomLikeInput<V> = V | BoundAtom<Atom<V>>;
+export type AtomLikeOptions<T extends object> = {
+    [K in keyof T]?: AtomLikeInput<T[K]>;
+};
+export type AtomizeResult<V, In> = In extends BoundAtom<infer A> ? BoundAtom<A & Atom<V>> : BoundAtom<PrimitiveAtom<V>>;
+type OptOrDefault<Opts, K extends PropertyKey, D> = K extends keyof Opts ? Opts[K] : D;
+export type Field<T, K extends string, Opts> = AtomizeResult<T, OptOrDefault<Opts, K, T>>;
+export {};

package/dist/core/common-types/axes.d.ts

@@ -0,0 +1,3 @@
+export type AxisDir = "x" | "y" | "z";
+export type PlaneDir = "xy" | "xz" | "yz";
+export type PointDraggableDir = AxisDir | PlaneDir | "xyz" | "none";

package/dist/core/common-types/colors.d.ts

@@ -0,0 +1 @@
+export type Color = string;

package/dist/core/common-types/drag-utils.d.ts

@@ -0,0 +1,4 @@
+import type { PointDraggableDir } from "./axes";
+import type { Vec3 } from "./vec3";
+/** Apply axis/plane constraint to a target position relative to a current position. */
+export declare function applyDragConstraint(current: Vec3, target: Vec3, constraint: PointDraggableDir): Vec3;

package/dist/core/common-types/interaction-events.d.ts

@@ -0,0 +1,37 @@
+import type { ItemId, ItemKind } from "./item-registry";
+import type { Vec3 } from "./vec3";
+import type { Vec2 } from "./vec2";
+type BaseInteractionEvent<K extends ItemKind = ItemKind> = {
+    itemId: ItemId;
+    itemKind: K;
+    worldPosition: Vec3;
+    screenPosition: Vec2;
+    ray: {
+        origin: Vec3;
+        direction: Vec3;
+    };
+};
+export type DragEvent<K extends ItemKind = ItemKind> = BaseInteractionEvent<K> & {
+    type: "drag";
+    phase: "start" | "move" | "end";
+    startWorldPosition: Vec3;
+    delta: Vec3;
+};
+export type ClickEvent<K extends ItemKind = ItemKind> = BaseInteractionEvent<K> & {
+    type: "click";
+};
+export type HoverEvent<K extends ItemKind = ItemKind> = BaseInteractionEvent<K> & {
+    type: "hover";
+    phase: "enter" | "move" | "leave";
+};
+export type InteractionEvent<K extends ItemKind = ItemKind> = DragEvent<K> | ClickEvent<K> | HoverEvent<K>;
+export type InteractionEventType = "drag" | "click" | "hover";
+export type DragHandler<K extends ItemKind = ItemKind> = (event: DragEvent<K>) => void;
+export type ClickHandler<K extends ItemKind = ItemKind> = (event: ClickEvent<K>) => void;
+export type HoverHandler<K extends ItemKind = ItemKind> = (event: HoverEvent<K>) => void;
+export type InteractionHandler<K extends ItemKind = ItemKind> = {
+    drag: DragHandler<K>;
+    click: ClickHandler<K>;
+    hover: HoverHandler<K>;
+};
+export {};

package/dist/core/common-types/item-registry.d.ts

@@ -0,0 +1,49 @@
+import { type Point3DFields, type Point3DOptions, Point3D } from "../items/point3d";
+import { type Line3DFields, type Line3DOptions, Line3D } from "../items/line3d";
+import { type Camera3DFields, type Camera3DOptions, Camera3D } from "../items/camera3d";
+import { type ParametricFunction3DFields, type ParametricFunction3DOptions, ParametricFunction3D } from "../items/parametric-function3d";
+import { type Axes3DFields, type Axes3DOptions, Axes3D } from "../items/axes3d";
+import { type Grid3DFields, type Grid3DOptions, Grid3D } from "../items/grid3d";
+import { type Sphere3DFields, type Sphere3DOptions, Sphere3D } from "../items/sphere3d";
+import { type Vector3DFields, type Vector3DOptions, Vector3D } from "../items/vector3d";
+import { type Overlay3DFields, type Overlay3DOptions, Overlay3D } from "../items/overlay3d";
+import { type Plane3DFields, type Plane3DOptions, Plane3D } from "../items/plane3d";
+import type { Scene3D } from "../scene3d";
+import type { AtomLikeOptions } from "../atom-wrapper";
+export type ItemId = string;
+export type ItemKind = "point3d" | "line3d" | "camera3d" | "parametricfunction3d" | "axes3d" | "grid3d" | "sphere3d" | "vector3d" | "overlay3d" | "plane3d";
+export type ItemFieldsMap = {
+    point3d: Point3DFields;
+    line3d: Line3DFields;
+    camera3d: Camera3DFields;
+    parametricfunction3d: ParametricFunction3DFields;
+    axes3d: Axes3DFields;
+    grid3d: Grid3DFields;
+    sphere3d: Sphere3DFields;
+    vector3d: Vector3DFields;
+    overlay3d: Overlay3DFields;
+    plane3d: Plane3DFields;
+};
+export type ItemFields<K extends ItemKind> = ItemFieldsMap[K];
+export type ItemOptions<K extends ItemKind> = AtomLikeOptions<ItemFieldsMap[K]>;
+export type ItemSnapshot<K extends ItemKind = ItemKind> = K extends ItemKind ? {
+    id: ItemId;
+    kind: K;
+    isDirty: boolean;
+} & ItemFields<K> : never;
+export declare const itemFactory: {
+    readonly point3d: <Opts extends Point3DOptions>(scene: Scene3D, options: Opts) => Point3D<Opts>;
+    readonly line3d: <Opts extends Line3DOptions>(scene: Scene3D, options: Opts) => Line3D<Opts>;
+    readonly camera3d: <Opts extends Camera3DOptions>(scene: Scene3D, options: Opts) => Camera3D<Opts>;
+    readonly parametricfunction3d: <Opts extends ParametricFunction3DOptions>(scene: Scene3D, options: Opts) => ParametricFunction3D<Opts>;
+    readonly axes3d: <Opts extends Axes3DOptions>(scene: Scene3D, options: Opts) => Axes3D<Opts>;
+    readonly grid3d: <Opts extends Grid3DOptions>(scene: Scene3D, options: Opts) => Grid3D<Opts>;
+    readonly sphere3d: <Opts extends Sphere3DOptions>(scene: Scene3D, options: Opts) => Sphere3D<Opts>;
+    readonly vector3d: <Opts extends Vector3DOptions>(scene: Scene3D, options: Opts) => Vector3D<Opts>;
+    readonly overlay3d: <Opts extends Overlay3DOptions>(scene: Scene3D, options: Opts) => Overlay3D<Opts>;
+    readonly plane3d: <Opts extends Plane3DOptions>(scene: Scene3D, options: Opts) => Plane3D<Opts>;
+};
+export type ItemFactory<K extends ItemKind> = (typeof itemFactory)[K];
+export type ItemInstance<K extends ItemKind, Opts extends ItemOptions<K>> = K extends "point3d" ? Point3D<Opts> : K extends "line3d" ? Line3D<Opts> : K extends "camera3d" ? Camera3D<Opts> : K extends "parametricfunction3d" ? ParametricFunction3D<Opts> : K extends "axes3d" ? Axes3D<Opts> : K extends "grid3d" ? Grid3D<Opts> : K extends "sphere3d" ? Sphere3D<Opts> : K extends "vector3d" ? Vector3D<Opts> : K extends "overlay3d" ? Overlay3D<Opts> : K extends "plane3d" ? Plane3D<Opts> : never;
+export type ItemInstanceOf<K extends ItemKind = ItemKind> = K extends ItemKind ? ItemInstance<K, ItemOptions<K>> : never;
+export type Item = ItemInstanceOf<ItemKind>;

package/dist/core/common-types/overlay.d.ts

@@ -0,0 +1,3 @@
+export type OverlayFormat = "text" | "latex";
+export type OverlayAnchor = "center" | "top-left" | "top" | "top-right" | "left" | "right" | "bottom-left" | "bottom" | "bottom-right";
+export declare function anchorToTranslate(anchor: OverlayAnchor): string;

package/dist/core/common-types/tags.d.ts

@@ -0,0 +1 @@
+export type ItemTags = Array<string>;

package/dist/core/common-types/vec2.d.ts

@@ -0,0 +1,17 @@
+export type Vec2 = {
+    x: number;
+    y: number;
+};
+export declare function vec2(x: number, y: number): Vec2;
+export declare namespace Vec2 {
+    const ZERO: Readonly<Vec2>;
+    const ONE: Readonly<Vec2>;
+    function add(...vectors: Vec2[]): Vec2;
+    function subtract(a: Vec2, b: Vec2): Vec2;
+    function normalized(vec: Vec2): Vec2;
+    function scaled(vec: Vec2, scalar: number): Vec2;
+    function dot(a: Vec2, b: Vec2): number;
+    function cross(a: Vec2, b: Vec2): number;
+    function distance(a: Vec2, b: Vec2): number;
+    function distanceSquared(a: Vec2, b: Vec2): number;
+}

package/dist/core/common-types/vec3.d.ts

@@ -0,0 +1,17 @@
+export type Vec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function vec3(x: number, y: number, z: number): Vec3;
+export declare namespace Vec3 {
+    const ZERO: Readonly<Vec3>;
+    const ONE: Readonly<Vec3>;
+    function asArray(vec: Vec3): [number, number, number];
+    function add(...vectors: Vec3[]): Vec3;
+    function subtract(a: Vec3, b: Vec3): Vec3;
+    function normalized(vec: Vec3): Vec3;
+    function scaled(vec: Vec3, scalar: number): Vec3;
+    function dot(a: Vec3, b: Vec3): number;
+    function cross(a: Vec3, b: Vec3): Vec3;
+}

package/dist/core/item.d.ts

@@ -0,0 +1,27 @@
+import type { Atom } from "jotai";
+import type { Store } from "jotai/vanilla/store";
+import type { BoundAtom } from "./atom-wrapper";
+import type { ItemId, ItemKind, ItemSnapshot } from "./common-types/item-registry";
+import type { InteractionEventType, InteractionHandler, DragHandler, ClickHandler, HoverHandler, DragEvent, ClickEvent, HoverEvent } from "./common-types/interaction-events";
+export declare abstract class BaseItem<T, K extends ItemKind> {
+    abstract kind: K;
+    id: ItemId;
+    isDirty: boolean;
+    invalidateScene: () => void;
+    store?: Store;
+    eventHandlers: Map<InteractionEventType, DragHandler | ClickHandler | HoverHandler>;
+    markDirty(): void;
+    atomFields: Set<BoundAtom<Atom<any>>>;
+    addAtomFields(...fields: BoundAtom<Atom<any>>[]): void;
+    atomSceneSubscriptions: Set<() => void>;
+    setupAtomInvalidations(invalidateScene: () => void): void;
+    removeFromScene(): void;
+    on<E extends InteractionEventType>(event: E, handler: InteractionHandler<K>[E]): void;
+    off(event: InteractionEventType): void;
+    getHandler<E extends InteractionEventType>(event: E): InteractionHandler<K>[E] | undefined;
+    getCursorState(): string | null;
+    handleDrag?(event: DragEvent<K>): void;
+    handleClick?(event: ClickEvent<K>): void;
+    handleHover?(event: HoverEvent<K>): void;
+    abstract getItemSnapshot(): ItemSnapshot<K>;
+}

package/dist/core/items/axes3d.d.ts

@@ -0,0 +1,39 @@
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import { BaseItem } from "../item";
+import type { Scene3D } from "../scene3d";
+export type PointerEvents = "auto" | "none";
+export type Axes3DFields = {
+    tags: ItemTags;
+    x: boolean | [number, number];
+    y: boolean | [number, number];
+    z: boolean | [number, number];
+    color: Color;
+    thickness: number;
+    pointerEvents: PointerEvents;
+};
+export type Axes3DOptions = AtomLikeOptions<Axes3DFields>;
+export declare class Axes3D<Opts extends Axes3DOptions = {}> extends BaseItem<Axes3DFields, "axes3d"> {
+    kind: "axes3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    x: Field<boolean | [number, number], "x", Opts>;
+    y: Field<boolean | [number, number], "y", Opts>;
+    z: Field<boolean | [number, number], "z", Opts>;
+    color: Field<Color, "color", Opts>;
+    thickness: Field<number, "thickness", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Axes3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "axes3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        x: boolean | [number, number];
+        y: boolean | [number, number];
+        z: boolean | [number, number];
+        color: string;
+        thickness: number;
+        pointerEvents: PointerEvents;
+    };
+}

package/dist/core/items/camera3d.d.ts

@@ -0,0 +1,43 @@
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import { type Vec3 } from "../common-types/vec3";
+import type { Scene3D } from "../scene3d";
+import { BaseItem } from "../item";
+type CameraProjection = "perspective" | "orthogonal";
+type CameraControls = "orbit" | "pan";
+export type Camera3DFields = {
+    position: Vec3;
+    lookAt: Vec3;
+    projection: CameraProjection;
+    controls: CameraControls;
+    fov: number;
+    zoom: number;
+    near: number;
+    far: number;
+};
+export type Camera3DOptions = AtomLikeOptions<Camera3DFields>;
+export declare class Camera3D<Opts extends Camera3DOptions = {}> extends BaseItem<Camera3DFields, "camera3d"> {
+    kind: "camera3d";
+    position: Field<Vec3, "position", Opts>;
+    lookAt: Field<Vec3, "lookAt", Opts>;
+    projection: Field<CameraProjection, "projection", Opts>;
+    controls: Field<CameraControls, "controls", Opts>;
+    fov: Field<number, "fov", Opts>;
+    zoom: Field<number, "zoom", Opts>;
+    near: Field<number, "near", Opts>;
+    far: Field<number, "far", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Camera3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "camera3d";
+        isDirty: boolean;
+        position: Vec3;
+        lookAt: Vec3;
+        projection: CameraProjection;
+        controls: CameraControls;
+        fov: number;
+        zoom: number;
+        near: number;
+        far: number;
+    };
+}
+export {};

package/dist/core/items/grid3d.d.ts

@@ -0,0 +1,47 @@
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import type { Scene3D } from "../scene3d";
+import { BaseItem } from "../item";
+type PlaneDir = "xy" | "xz" | "yz";
+export type PointerEvents = "auto" | "none";
+export type Grid3DFields = {
+    tags: ItemTags;
+    plane: PlaneDir;
+    range1: boolean | [number, number];
+    range2: boolean | [number, number];
+    offset: number;
+    gap: number;
+    color: Color;
+    thickness: number;
+    pointerEvents: PointerEvents;
+};
+export type Grid3DOptions = AtomLikeOptions<Grid3DFields>;
+export declare class Grid3D<Opts extends Grid3DOptions = {}> extends BaseItem<Grid3DFields, "grid3d"> {
+    kind: "grid3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    plane: Field<PlaneDir, "plane", Opts>;
+    range1: Field<boolean | [number, number], "range1", Opts>;
+    range2: Field<boolean | [number, number], "range2", Opts>;
+    gap: Field<number, "gap", Opts>;
+    offset: Field<number, "offset", Opts>;
+    color: Field<Color, "color", Opts>;
+    thickness: Field<number, "thickness", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Grid3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "grid3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        plane: PlaneDir;
+        range1: boolean | [number, number];
+        range2: boolean | [number, number];
+        offset: number;
+        gap: number;
+        color: string;
+        thickness: number;
+        pointerEvents: PointerEvents;
+    };
+}
+export {};

package/dist/core/items/line3d.d.ts

@@ -0,0 +1,37 @@
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import type { Color } from "../common-types/colors";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import { BaseItem } from "../item";
+import type { Scene3D } from "../scene3d";
+export type PointerEvents = "auto" | "none";
+export type Line3DFields = {
+    tags: ItemTags;
+    start: Vec3;
+    end: Vec3;
+    color: Color;
+    thickness: number;
+    pointerEvents: PointerEvents;
+};
+export type Line3DOptions = AtomLikeOptions<Line3DFields>;
+export declare class Line3D<Opts extends Line3DOptions = {}> extends BaseItem<Line3DFields, "line3d"> {
+    kind: "line3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    start: Field<Vec3, "start", Opts>;
+    end: Field<Vec3, "end", Opts>;
+    color: Field<Color, "color", Opts>;
+    thickness: Field<number, "thickness", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Line3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "line3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        start: Vec3;
+        end: Vec3;
+        color: string;
+        thickness: number;
+        pointerEvents: PointerEvents;
+    };
+}

package/dist/core/items/overlay3d.d.ts

@@ -0,0 +1,51 @@
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import { type Vec2 } from "../common-types/vec2";
+import type { OverlayAnchor, OverlayFormat } from "../common-types/overlay";
+import type { PointerEvents } from "./point3d";
+import { BaseItem } from "../item";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Scene3D } from "../scene3d";
+export type Overlay3DFields = {
+    tags: ItemTags;
+    position: Vec3;
+    content: string;
+    format: OverlayFormat;
+    offset: Vec2;
+    anchor: OverlayAnchor;
+    visible: boolean;
+    className: string;
+    style: string;
+    pointerEvents: PointerEvents;
+};
+export type Overlay3DOptions = AtomLikeOptions<Overlay3DFields>;
+export declare class Overlay3D<Opts extends Overlay3DOptions = {}> extends BaseItem<Overlay3DFields, "overlay3d"> {
+    kind: "overlay3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    position: Field<Vec3, "position", Opts>;
+    content: Field<string, "content", Opts>;
+    format: Field<OverlayFormat, "format", Opts>;
+    offset: Field<Vec2, "offset", Opts>;
+    anchor: Field<OverlayAnchor, "anchor", Opts>;
+    visible: Field<boolean, "visible", Opts>;
+    className: Field<string, "className", Opts>;
+    style: Field<string, "style", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Overlay3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "overlay3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        position: Vec3;
+        content: string;
+        format: OverlayFormat;
+        offset: Vec2;
+        anchor: OverlayAnchor;
+        visible: boolean;
+        className: string;
+        style: string;
+        pointerEvents: PointerEvents;
+    };
+    getCursorState(): null;
+}

package/dist/core/items/parametric-function3d.d.ts

@@ -0,0 +1,45 @@
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import type { Vec3 } from "../common-types/vec3";
+import { BaseItem } from "../item";
+import type { Scene3D } from "../scene3d";
+type ParametricFunction3DFunc = (t: number) => Vec3;
+export type PointerEvents = "auto" | "none";
+export type ParametricFunction3DFields = {
+    tags: ItemTags;
+    f: ParametricFunction3DFunc;
+    tStart: number;
+    tEnd: number;
+    color: Color;
+    thickness: number;
+    samples: number;
+    pointerEvents: PointerEvents;
+};
+export type ParametricFunction3DOptions = AtomLikeOptions<ParametricFunction3DFields>;
+export declare class ParametricFunction3D<Opts extends ParametricFunction3DOptions = {}> extends BaseItem<ParametricFunction3DFields, "parametricfunction3d"> {
+    kind: "parametricfunction3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    f: Field<ParametricFunction3DFunc, "f", Opts>;
+    tStart: Field<number, "tStart", Opts>;
+    tEnd: Field<number, "tEnd", Opts>;
+    color: Field<Color, "color", Opts>;
+    thickness: Field<number, "thickness", Opts>;
+    samples: Field<number, "samples", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & ParametricFunction3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "parametricfunction3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        f: ParametricFunction3DFunc;
+        tStart: number;
+        tEnd: number;
+        color: string;
+        thickness: number;
+        samples: number;
+        pointerEvents: PointerEvents;
+    };
+}
+export {};

package/dist/core/items/plane3d.d.ts

@@ -0,0 +1,46 @@
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import { BaseItem } from "../item";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Scene3D } from "../scene3d";
+export type PointerEvents = "auto" | "none";
+export type Plane3DFields = {
+    tags: ItemTags;
+    point: Vec3;
+    normal: Vec3;
+    width: number;
+    height: number;
+    color: Color;
+    opacity: number;
+    showEdges: boolean;
+    pointerEvents: PointerEvents;
+};
+export type Plane3DOptions = AtomLikeOptions<Plane3DFields>;
+export declare class Plane3D<Opts extends Plane3DOptions = {}> extends BaseItem<Plane3DFields, "plane3d"> {
+    kind: "plane3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    point: Field<Vec3, "point", Opts>;
+    normal: Field<Vec3, "normal", Opts>;
+    width: Field<number, "width", Opts>;
+    height: Field<number, "height", Opts>;
+    color: Field<Color, "color", Opts>;
+    opacity: Field<number, "opacity", Opts>;
+    showEdges: Field<boolean, "showEdges", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Plane3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "plane3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        point: Vec3;
+        normal: Vec3;
+        width: number;
+        height: number;
+        color: string;
+        opacity: number;
+        showEdges: boolean;
+        pointerEvents: PointerEvents;
+    };
+}

package/dist/core/items/point3d.d.ts

@@ -0,0 +1,44 @@
+import type { PointDraggableDir } from "../common-types/axes";
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import { BaseItem } from "../item";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Scene3D } from "../scene3d";
+import type { ClickEvent, DragEvent } from "../common-types/interaction-events";
+export type PointerEvents = "auto" | "none";
+export type Point3DFields = {
+    tags: ItemTags;
+    coords: Vec3;
+    draggable: PointDraggableDir;
+    color: Color;
+    radius: number;
+    pointerEvents: PointerEvents;
+};
+export type Point3DOptions = AtomLikeOptions<Point3DFields>;
+export declare class Point3D<Opts extends Point3DOptions = {}> extends BaseItem<Point3DFields, "point3d"> {
+    kind: "point3d";
+    warnedReadOnly: boolean;
+    private _dragOffset;
+    tags: Field<ItemTags, "tags", Opts>;
+    coords: Field<Vec3, "coords", Opts>;
+    draggable: Field<PointDraggableDir, "draggable", Opts>;
+    color: Field<Color, "color", Opts>;
+    radius: Field<number, "radius", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Point3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "point3d";
+        isDirty: boolean;
+        coords: Vec3;
+        tags: ItemTags;
+        draggable: PointDraggableDir;
+        color: string;
+        radius: number;
+        pointerEvents: PointerEvents;
+    };
+    getCursorState(): "grab" | null;
+    handleClick(event: ClickEvent<"point3d">): void;
+    handleDrag(event: DragEvent<"point3d">): void;
+}

package/dist/core/items/sphere3d.d.ts

@@ -0,0 +1,37 @@
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import { BaseItem } from "../item";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Scene3D } from "../scene3d";
+export type PointerEvents = "auto" | "none";
+export type Sphere3DFields = {
+    tags: ItemTags;
+    center: Vec3;
+    radius: number;
+    color: Color;
+    opacity: number;
+    pointerEvents: PointerEvents;
+};
+export type Sphere3DOptions = AtomLikeOptions<Sphere3DFields>;
+export declare class Sphere3D<Opts extends Sphere3DOptions = {}> extends BaseItem<Sphere3DFields, "sphere3d"> {
+    kind: "sphere3d";
+    tags: Field<ItemTags, "tags", Opts>;
+    center: Field<Vec3, "center", Opts>;
+    radius: Field<number, "radius", Opts>;
+    color: Field<Color, "color", Opts>;
+    opacity: Field<number, "opacity", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Sphere3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "sphere3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        center: Vec3;
+        radius: number;
+        color: string;
+        opacity: number;
+        pointerEvents: PointerEvents;
+    };
+}