@woosh/meep-engine 3.14.5 → 3.14.6

package/editor/tools/v2/handle/gizmo_drag_plane.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The plane a drag is measured on.
+ *
+ * **A drag is a pointer moving across a surface, and which surface decides what the drag means.**
+ * Dragging the X arm has to read as movement along X however the camera is angled, so the plane
+ * holding X is chosen to be the one most nearly facing the eye — that is what the cross products
+ * below do. Dragging a corner tile is movement on that tile's own plane. A free drag, and every
+ * rotation, is measured on the plane facing the camera.
+ *
+ * The three version reached the same plane by orienting a large invisible `PlaneGeometry` with
+ * `Matrix4.lookAt` and raycasting it. This is the same construction with the mesh taken out: a
+ * normal and a point are what an intersection needs, and the renderer was never involved in
+ * deciding either.
+ *
+ * @param {Vector3} result written with a unit normal
+ * @param {string} mode one of {@link TransformMode}
+ * @param {string} axis the handle being dragged
+ * @param {string} space `'world'` or `'local'`
+ * @param {Quaternion} object_rotation the object's world rotation, which `'local'` measures against
+ * @param {Vector3} eye unit, from the gizmo towards the camera
+ * @param {Vector3} camera_forward unit, the direction the camera looks along
+ */
+export function gizmo_drag_plane_normal(result: Vector3, mode: string, axis: string, space: string, object_rotation: Quaternion, eye: Vector3, camera_forward: Vector3): void;
+/**
+ * Where a ray meets a plane.
+ *
+ * @param {Vector3} result written with the point
+ * @param {Vector3} origin
+ * @param {Vector3} direction unit
+ * @param {Vector3} plane_point
+ * @param {Vector3} plane_normal unit
+ * @returns {boolean} `false` when the ray runs parallel to the plane, which is a pointer that has
+ * no position on it rather than an error
+ */
+export function gizmo_ray_plane_point(result: Vector3, origin: Vector3, direction: Vector3, plane_point: Vector3, plane_normal: Vector3): boolean;
+import Vector3 from "../../../../src/core/geom/Vector3.js";
+//# sourceMappingURL=gizmo_drag_plane.d.ts.map

package/editor/tools/v2/handle/gizmo_drag_plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_drag_plane.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_drag_plane.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gDARW,OAAO,QACP,MAAM,QACN,MAAM,SACN,MAAM,oCAEN,OAAO,kBACP,OAAO,QAqEjB;AAED;;;;;;;;;;GAUG;AACH,8CARW,OAAO,UACP,OAAO,aACP,OAAO,eACP,OAAO,gBACP,OAAO,GACL,OAAO,CAiBnB;oBA3ImB,sCAAsC"}

package/editor/tools/v2/handle/gizmo_draw.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Record one frame's worth of the gizmo.
+ *
+ * @param {string} mode one of {@link TransformMode}
+ * @param {Vector3} position where the gizmo is, world
+ * @param {Quaternion} rotation how its axes are turned — identity in world space, the object's own
+ * rotation in local space and always in scale mode
+ * @param {number} size how big it is, world units per gizmo unit
+ * @param {string|null} active the handle under the pointer or being dragged, drawn highlighted
+ * @param {Vector3} camera_forward unit, the direction the camera looks along
+ */
+export function gizmo_draw(mode: string, position: Vector3, rotation: Quaternion, size: number, active: string | null, camera_forward: Vector3): void;
+import Vector3 from "../../../../src/core/geom/Vector3.js";
+//# sourceMappingURL=gizmo_draw.d.ts.map

package/editor/tools/v2/handle/gizmo_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_draw.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_draw.js"],"names":[],"mappings":"AAgVA;;;;;;;;;;GAUG;AACH,iCARW,MAAM,YACN,OAAO,8BAGP,MAAM,UACN,MAAM,GAAC,IAAI,kBACX,OAAO,QAqDjB;oBA7YmB,sCAAsC"}

package/editor/tools/v2/handle/gizmo_handles.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @param {string} mode one of {@link TransformMode}
+ * @returns {GizmoHandle[]}
+ */
+export function gizmo_handles_of_mode(mode: string): GizmoHandle[];
+/**
+ * Which handle a ray is over.
+ *
+ * The ray is brought into the gizmo's own space once — translated, turned and scaled — and every
+ * handle is then a shape about the origin. That is one inverse transform for the whole set rather
+ * than a world-space shape per handle, and it is why the handles can be written as plainly as they
+ * are.
+ *
+ * @param {GizmoHandle[]} handles
+ * @param {Vector3} origin world
+ * @param {Vector3} direction world, unit
+ * @param {Vector3} position where the gizmo is
+ * @param {Quaternion} rotation how it is turned
+ * @param {number} size how big it is drawn
+ * @returns {string|null} the handle's axis, or `null` where the ray is over none
+ */
+export function gizmo_pick_handle(handles: GizmoHandle[], origin: Vector3, direction: Vector3, position: Vector3, rotation: Quaternion, size: number): string | null;
+/**
+ * One thing the pointer can be over.
+ *
+ * **A handle is a name and a shape, and the name is the contract.** `TransformControls` decides what
+ * a drag does from `'X'`, `'XY'`, `'XYZ'`, `'E'` — the same vocabulary the three gizmo used and the
+ * same one `TransformToolV2.spec.js` drives — so what this replaces is the mesh that carried the
+ * name, not the name itself.
+ */
+export class GizmoHandle {
+    /**
+     * @type {string}
+     */
+    axis: string;
+    /**
+     * Whether a ray in the gizmo's own space is on this handle.
+     *
+     * @param {Vector3} origin
+     * @param {Vector3} direction unit
+     * @returns {boolean}
+     */
+    hit(origin: Vector3, direction: Vector3): boolean;
+}
+/**
+ * An arm along one axis — the shafts and arrowheads of translate and scale.
+ */
+export class GizmoArmHandle extends GizmoHandle {
+    /**
+     * @param {string} axis
+     * @param {number[]} direction
+     * @returns {GizmoArmHandle}
+     */
+    static along(axis: string, direction: number[]): GizmoArmHandle;
+    /**
+     * @type {Vector3}
+     */
+    direction: Vector3;
+    /**
+     * @type {number}
+     */
+    radius: number;
+    /**
+     * @type {number}
+     */
+    from: number;
+    /**
+     * @type {number}
+     */
+    to: number;
+    hit(origin: any, direction: any): boolean;
+}
+/**
+ * A tile on one of the three planes — the corner squares that drag in two axes at once.
+ */
+export class GizmoTileHandle extends GizmoHandle {
+    /**
+     * @param {string} axis
+     * @param {number[]} centre
+     * @param {number[]} half
+     * @returns {GizmoTileHandle}
+     */
+    static at(axis: string, centre: number[], half: number[]): GizmoTileHandle;
+    /**
+     * @type {Vector3}
+     */
+    centre: Vector3;
+    /**
+     * @type {Vector3}
+     */
+    half: Vector3;
+    hit(origin: any, direction: any): boolean;
+}
+/**
+ * The handle in the middle — uniform scale, free translate, or the free-rotation ball.
+ */
+export class GizmoBallHandle extends GizmoHandle {
+    /**
+     * @param {string} axis
+     * @param {number} radius
+     * @returns {GizmoBallHandle}
+     */
+    static of(axis: string, radius: number): GizmoBallHandle;
+    /**
+     * @type {number}
+     */
+    radius: number;
+    hit(origin: any, direction: any): boolean;
+}
+/**
+ * A rotation band, in the plane one axis is normal to.
+ */
+export class GizmoBandHandle extends GizmoHandle {
+    /**
+     * @param {string} axis
+     * @param {number[]} normal
+     * @param {number} radius
+     * @returns {GizmoBandHandle}
+     */
+    static about(axis: string, normal: number[], radius: number): GizmoBandHandle;
+    /**
+     * @type {Vector3}
+     */
+    normal: Vector3;
+    /**
+     * @type {number}
+     */
+    radius: number;
+    /**
+     * @type {number}
+     */
+    tube: number;
+    hit(origin: any, direction: any): boolean;
+}
+/**
+ * The outer rotation band, which faces the viewer wherever the viewer is.
+ *
+ * It has no axis of its own in the gizmo's space — that is the point of it — so it is a separate
+ * class rather than a {@link GizmoBandHandle} whose normal something has to keep up to date.
+ */
+export class GizmoScreenBandHandle extends GizmoHandle {
+    /**
+     * @param {string} axis
+     * @param {number} radius
+     * @returns {GizmoScreenBandHandle}
+     */
+    static of(axis: string, radius: number): GizmoScreenBandHandle;
+    /**
+     * @type {number}
+     */
+    radius: number;
+    /**
+     * @type {number}
+     */
+    tube: number;
+    hit(origin: any, direction: any): boolean;
+}
+import Vector3 from "../../../../src/core/geom/Vector3.js";
+import Quaternion from "../../../../src/core/geom/Quaternion.js";
+//# sourceMappingURL=gizmo_handles.d.ts.map

package/editor/tools/v2/handle/gizmo_handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_handles.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_handles.js"],"names":[],"mappings":"AAiSA;;;GAGG;AACH,4CAHW,MAAM,GACJ,WAAW,EAAE,CAgBzB;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,2CARW,WAAW,EAAE,UACb,OAAO,aACP,OAAO,YACP,OAAO,YACP,UAAU,QACV,MAAM,GACJ,MAAM,GAAC,IAAI,CAyBvB;AA/VD;;;;;;;GAOG;AACH;IACI;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,YAJW,OAAO,aACP,OAAO,GACL,OAAO,CAInB;CACJ;AAED;;GAEG;AACH;IAqBI;;;;OAIG;IACH,mBAJW,MAAM,aACN,MAAM,EAAE,GACN,cAAc,CAS1B;IAhCD;;OAEG;IACH,WAFU,OAAO,CAEgB;IAEjC;;OAEG;IACH,QAFU,MAAM,CAEH;IAEb;;OAEG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,IAFU,MAAM,CAET;IAgBP,0CAUC;CACJ;AAED;;GAEG;AACH;IAWI;;;;;OAKG;IACH,gBALW,MAAM,UACN,MAAM,EAAE,QACR,MAAM,EAAE,GACN,eAAe,CAU3B;IAxBD;;OAEG;IACH,QAFU,OAAO,CAEM;IAEvB;;OAEG;IACH,MAFU,OAAO,CAEkB;IAkBnC,0CAOC;CACJ;AAED;;GAEG;AACH;IAMI;;;;OAIG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,eAAe,CAS3B;IAjBD;;OAEG;IACH,QAFU,MAAM,CAEH;IAgBb,0CAMC;CACJ;AAED;;GAEG;AACH;IAgBI;;;;;OAKG;IACH,mBALW,MAAM,UACN,MAAM,EAAE,UACR,MAAM,GACJ,eAAe,CAU3B;IA7BD;;OAEG;IACH,QAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,QAFU,MAAM,CAEH;IAEb;;OAEG;IACH,MAFU,MAAM,CAEL;IAkBX,0CAMC;CACJ;AAED;;;;;GAKG;AACH;IAWI;;;;OAIG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,qBAAqB,CASjC;IAtBD;;OAEG;IACH,QAFU,MAAM,CAEF;IAEd;;OAEG;IACH,MAFU,MAAM,CAEL;IAgBX,0CAMC;CACJ;oBAjPmB,sCAAsC;uBADnC,yCAAyC"}

package/editor/tools/v2/handle/gizmo_ray_shapes.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Whether a ray is on a handle, for the four shapes a handle can be.
+ *
+ * **These are the pickers the three gizmo drew invisible meshes for** — cones along each axis, boxes
+ * for the plane handles, a sphere in the middle, tori for the rotation bands — and every one of them
+ * has a closed form. Raycasting a mesh to find out which arrow the pointer is over was a way of
+ * asking the renderer a question the geometry can answer.
+ *
+ * Everything here is in the gizmo's own space, where an axis is an axis and a plane handle is
+ * axis-aligned. Whoever asks brings the ray into that space first, which is one inverse transform
+ * rather than a transform per handle.
+ */
+/**
+ * An arm: the segment from the origin along an axis, with a radius.
+ *
+ * @param {number} axis_x unit
+ * @param {number} axis_y
+ * @param {number} axis_z
+ * @param {number} radius
+ * @param {number} from distance along the axis where the arm starts
+ * @param {number} to distance along the axis where it ends — a negative value is the opposite arm
+ * @param {number} origin_x ray
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x unit
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function ray_hits_capsule(axis_x: number, axis_y: number, axis_z: number, radius: number, from: number, to: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+/**
+ * @param {number} centre_x
+ * @param {number} centre_y
+ * @param {number} centre_z
+ * @param {number} radius
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x unit
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function ray_hits_sphere(centre_x: number, centre_y: number, centre_z: number, radius: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+/**
+ * An axis-aligned tile, given by its centre and its half-extents.
+ *
+ * @param {number} centre_x
+ * @param {number} centre_y
+ * @param {number} centre_z
+ * @param {number} half_x
+ * @param {number} half_y
+ * @param {number} half_z
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x unit
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function ray_hits_box(centre_x: number, centre_y: number, centre_z: number, half_x: number, half_y: number, half_z: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+/**
+ * A band in the plane an axis is normal to: a circle of `radius`, `tube` thick.
+ *
+ * @param {number} normal_x unit
+ * @param {number} normal_y
+ * @param {number} normal_z
+ * @param {number} radius
+ * @param {number} tube how far either side of the circle still counts
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x unit
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function ray_hits_ring(normal_x: number, normal_y: number, normal_z: number, radius: number, tube: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+/**
+ * A band that always faces the viewer: a circle of `radius` about the origin, seen face-on.
+ *
+ * **This needs no camera, though the shape it describes depends on one.** A circle of radius `r`
+ * turned to face the eye is exactly the set of rays whose closest approach to its centre is `r` — so
+ * the perpendicular distance from the centre to the ray decides it, and no view direction has to be
+ * passed in for the answer to be right.
+ *
+ * The rotation gizmo's outer band is dragged about the eye axis, and this is the shape that matches
+ * that: a band picked in one frame and dragged in another is a handle that does not do what it looks
+ * like it does.
+ *
+ * @param {number} radius
+ * @param {number} tube how far either side of the circle still counts
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x unit
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function ray_hits_screen_ring(radius: number, tube: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): boolean;
+//# sourceMappingURL=gizmo_ray_shapes.d.ts.map

package/editor/tools/v2/handle/gizmo_ray_shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gizmo_ray_shapes.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_ray_shapes.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,yCAdW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,QACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAmCnB;AAED;;;;;;;;;;;;GAYG;AACH,0CAZW,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,uCAdW,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wCAbW,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CA4BnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,6CAVW,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,OAAO,CA0BnB"}

package/editor/view/GridPickCoordinateView.d.ts

@@ -0,0 +1,22 @@
+export default GridPickCoordinateView;
+declare class GridPickCoordinateView extends View {
+    /**
+     *
+     * @param {Editor} editor
+     * @constructor
+     */
+    constructor(editor: Editor);
+    $el: import("../../src/view/DOM.js").DOM;
+    el: Element;
+    pointer: PointerDevice;
+    editor: Editor;
+    pick(x: any, y: any): void;
+    /**
+     *
+     * @return {PointerDevice}
+     */
+    getPointer(): PointerDevice;
+}
+import View from "../../src/view/View.js";
+import { PointerDevice } from "../../src/engine/input/devices/PointerDevice.js";
+//# sourceMappingURL=GridPickCoordinateView.d.ts.map

package/editor/view/GridPickCoordinateView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridPickCoordinateView.d.ts","sourceRoot":"","sources":["../../../editor/view/GridPickCoordinateView.js"],"names":[],"mappings":";AAMA;IACI;;;;OAIG;IACH,4BAaC;IAVG,yCAAwB;IAExB,YAAqB;IAIrB,uBAAsC;IAEtC,eAAoB;IAIxB,2BAyBC;IAED;;;OAGG;IACH,cAFY,aAAa,CAIxB;CAwBJ;iBApFgB,wBAAwB;8BAEX,iDAAiD"}

package/editor/view/ecs/ComponentControlView.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @template T
+ */
+export class ComponentControlView<T> extends View {
+    /**
+     * @template T
+     * @param {number} entity
+     * @param {T} component
+     * @param {EntityManager} entityManager
+     * @param {View} vController
+     * @param engine
+     * @constructor
+     */
+    constructor(entity: number, component: T_1, entityManager: EntityManager, vController: View, engine: any);
+    signal: {
+        remove: Signal;
+    };
+    el: Element;
+    folded: ObservedBoolean;
+}
+import View from "../../../src/view/View.js";
+import Signal from "../../../src/core/events/signal/Signal.js";
+import ObservedBoolean from "../../../src/core/model/ObservedBoolean.js";
+//# sourceMappingURL=ComponentControlView.d.ts.map

package/editor/view/ecs/ComponentControlView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentControlView.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/ComponentControlView.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IAKI;;;;;;;;OAQG;IACH,oBAPW,MAAM,6DAGN,IAAI,eAiGd;IA1GD;;MAEE;IAkBE,YAAkB;IAEH,wBAAwC;CAqF9D;iBA1HgB,2BAA2B;mBACzB,2CAA2C;4BAElC,4CAA4C"}

package/editor/view/ecs/EntityEditor.d.ts

@@ -0,0 +1,25 @@
+export default EntityEditor;
+declare class EntityEditor extends View {
+    constructor(editor: any);
+    el: Element;
+    model: ObservedValue;
+    /**
+     * @type {ObservedValue<EntityManager>}
+     */
+    entityManager: any;
+    components: List<any>;
+    /**
+     *
+     * @type {Map<Object, ComponentControlView>}
+     */
+    componentControllers: Map<any, ComponentControlView<any>>;
+    vLabelEntity: LabelView;
+    handlers: {};
+    #private;
+}
+import View from "../../../src/view/View.js";
+import ObservedValue from '../../../src/core/model/ObservedValue.js';
+import List from '../../../src/core/collection/list/List.js';
+import { ComponentControlView } from "./ComponentControlView.js";
+import LabelView from '../../../src/view/common/LabelView.js';
+//# sourceMappingURL=EntityEditor.d.ts.map

package/editor/view/ecs/EntityEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBAyOC;IAhOG,YAAkB;IAGlB,qBAAoC;IACpC;;OAEG;IACH,mBAA4C;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAsGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBAzQgB,2BAA2B;0BATlB,0CAA0C;iBADnD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}

package/editor/view/ecs/EntityList.d.ts

@@ -0,0 +1,22 @@
+export default EntityListView;
+declare class EntityListView extends View {
+    /**
+     *
+     * @param {Editor} editor
+     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} decorators
+     */
+    constructor({ editor, decorators }: Editor);
+    el: HTMLDivElement;
+    on: {};
+    editor: Editor;
+    handlers: {
+        addOne: (entity: any) => void;
+        removeOne: (entity: any) => void;
+        selectOne: (entity: any) => void;
+        deselectOne: (entity: any) => void;
+        reset: () => void;
+    };
+    layout(): void;
+}
+import View from "../../../src/view/View.js";
+//# sourceMappingURL=EntityList.d.ts.map

package/editor/view/ecs/EntityList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityList.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityList.js"],"names":[],"mappings":";AA4DA;IAGI;;;;OAIG;IACH,4CAmJC;IA1JD,mBAAmC;IAgB3B,OAAY;IAQhB,eAAoB;IAuGpB;;;;;;MAUC;IAmBL,eAEC;CAsCJ;iBAzPgB,2BAA2B"}

package/editor/view/ecs/HierarchicalEntityListView.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Entity tree over a dataset: roots are entities without a {@link ParentEntity}, children
+ * nest beneath their parent. Reacts to entity creation/removal while linked. Editor-owned
+ * entities (carrying {@link EditorEntity}) are not shown.
+ *
+ * Signals: `on.interact(entity, event)` on row click, `on.focus_request(entity)` on row
+ * double-click.
+ */
+export class HierarchicalEntityListView extends EmptyView {
+    constructor();
+    /**
+     *
+     * @param {number[]} entities
+     */
+    set selection(arg: number[]);
+    set dataset(arg: any);
+    /**
+     * Row filter matched against entity ids and names
+     * @param {string} v
+     */
+    set filter(arg: string);
+    #private;
+}
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+//# sourceMappingURL=HierarchicalEntityListView.d.ts.map

package/editor/view/ecs/HierarchicalEntityListView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HierarchicalEntityListView.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/HierarchicalEntityListView.js"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH;IAmRI,cAwBC;IAxID;;;OAGG;IACH,6BAEC;IAED,sBAYC;IAED;;;OAGG;IACH,wBAIC;;CA6HJ;sBAzUqB,yCAAyC"}

package/editor/view/ecs/components/DatGuiController.d.ts

@@ -0,0 +1,2 @@
+export { default } from "../../../../src/view/controller/dat/DatGuiController.js";
+//# sourceMappingURL=DatGuiController.d.ts.map

package/editor/view/ecs/components/DatGuiController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatGuiController.d.ts","sourceRoot":"","sources":["../../../../../editor/view/ecs/components/DatGuiController.js"],"names":[],"mappings":""}

package/editor/view/ecs/components/color/GaugeView.d.ts

@@ -1,12 +1,16 @@
 export class GaugeView extends GuiControl {
     /**
-     *
-     * @param {string} name
-     * @param {function} draw
-     * @param {string[]} classList
+     * @param {Object} options
+     * @param {string} options.name
+     * @param {function} options.draw
+     * @param {string[]} [options.classList]
      * @constructor
      */
-    constructor({ name, draw, classList }: string);
+    constructor({ name, draw, classList }: {
+        name: string;
+        draw: Function;
+        classList?: string[];
+    });
     render: () => void;
 }
 import GuiControl from "../../../../../src/view/controller/controls/GuiControl.js";

package/editor/view/ecs/components/color/GaugeView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GaugeView.d.ts","sourceRoot":"","sources":["GaugeView.js"],"names":[],"mappings":"AAOA;IACI;;;;;;OAMG;IACH,uCALW,MAAM,EA+FhB;IA9CG,mBAAoB;CA+C3B;uBA1GsB,2DAA2D"}
+{"version":3,"file":"GaugeView.d.ts","sourceRoot":"","sources":["GaugeView.js"],"names":[],"mappings":"AAOA;IACI;;;;;;OAMG;IACH;QAL2B,IAAI,EAApB,MAAM;QACY,IAAI;QACH,SAAS,GAA5B,MAAM,EAAE;OA6FlB;IA9CG,mBAAoB;CA+C3B;uBA1GsB,2DAA2D"}

package/editor/view/ecs/components/color/GaugeView.js

@@ -7,10 +7,10 @@ import { clamp01 } from "../../../../../src/core/math/clamp01.js";
 
 export class GaugeView extends GuiControl {
     /**
-     *
-     * @param {string} name
-     * @param {function} draw
-     * @param {string[]} classList
+     * @param {Object} options
+     * @param {string} options.name
+     * @param {function} options.draw
+     * @param {string[]} [options.classList]
      * @constructor
      */
     constructor({ name, draw, classList = [] }) {

package/editor/view/ecs/components/common/NumberController.d.ts

@@ -1,11 +1,15 @@
 export class NumberController extends View {
     /**
-     *
-     * @param {string[]} [classList]
-     * @param {number} [value]
-     * @param figures
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
+     * @param {number} [options.value]
+     * @param {number} [options.figures]
      */
-    constructor({ classList, value, figures }?: string[]);
+    constructor({ classList, value, figures }?: {
+        classList?: string[];
+        value?: number;
+        figures?: number;
+    });
     /**
      *
      * @type {Vector1}

package/editor/view/ecs/components/common/NumberController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NumberController.d.ts","sourceRoot":"","sources":["NumberController.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,4CAJW,MAAM,EAAE,EAsGlB;IA7FG;;;OAGG;IACH,OAFU,OAAO,CAEE;IAGnB,qBAAY;CAuFnB;iBA/GgB,iCAAiC;oBAC9B,yCAAyC"}
+{"version":3,"file":"NumberController.d.ts","sourceRoot":"","sources":["NumberController.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH;QAJ8B,SAAS,GAA5B,MAAM,EAAE;QACS,KAAK,GAAtB,MAAM;QACW,OAAO,GAAxB,MAAM;OAoGhB;IA7FG;;;OAGG;IACH,OAFU,OAAO,CAEE;IAGnB,qBAAY;CAuFnB;iBA/GgB,iCAAiC;oBAC9B,yCAAyC"}

package/editor/view/ecs/components/common/NumberController.js

@@ -5,10 +5,10 @@ const DEFAULT_VALUE = 0;
 
 export class NumberController extends View {
     /**
-     *
-     * @param {string[]} [classList]
-     * @param {number} [value]
-     * @param figures
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
+     * @param {number} [options.value]
+     * @param {number} [options.figures]
      */
     constructor({ classList = [], value = 0, figures = 6 } = {}) {
         super();

package/editor/view/ecs/components/common/NumericIntervalController.d.ts

@@ -0,0 +1,10 @@
+export class NumericIntervalController extends View {
+    /**
+     *
+     * @param {NumericInterval} interval
+     * @param {string} tag
+     */
+    constructor({ interval, tag }: NumericInterval);
+}
+import View from "../../../../../src/view/View.js";
+//# sourceMappingURL=NumericIntervalController.d.ts.map

package/editor/view/ecs/components/common/NumericIntervalController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumericIntervalController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/NumericIntervalController.js"],"names":[],"mappings":"AAMA;IACI;;;;OAIG;IACH,gDAkDC;CACJ;iBA7DgB,iCAAiC"}

package/editor/view/ecs/components/common/TextController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextController.d.ts","sourceRoot":"","sources":["TextController.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACI;;;;OAIG;IACH,mCAHW,MAAM,EAAE,EA+ClB;IAvCG;;;OAGG;IACH,OAFU,cAAc,CAEL;IAGnB,qBAAY;CAiCnB;iBAzDgB,iCAAiC;2BADvB,iDAAiD"}
+{"version":3,"file":"TextController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/TextController.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACI;;;;OAIG;IACH,mCAHW,MAAM,EAAE,EA+ClB;IAvCG;;;OAGG;IACH,OAFU,cAAc,CAEL;IAGnB,qBAAY;CAiCnB;iBAzDgB,iCAAiC;2BADvB,iDAAiD"}

package/editor/view/library/MeshLibraryView.d.ts

@@ -0,0 +1,16 @@
+export default MeshLibraryView;
+declare class MeshLibraryView extends View {
+    /**
+     *
+     * @param {MeshLibrary} library
+     * @param {Promise<ModelThumbnailSource>} thumbnails
+     * @constructor
+     */
+    constructor(library: MeshLibrary, thumbnails: Promise<ModelThumbnailSource>);
+    el: Element;
+    assets: List<any>;
+    layout: () => void;
+}
+import View from "../../../src/view/View.js";
+import List from "../../../src/core/collection/list/List.js";
+//# sourceMappingURL=MeshLibraryView.d.ts.map

package/editor/view/library/MeshLibraryView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshLibraryView.d.ts","sourceRoot":"","sources":["../../../../editor/view/library/MeshLibraryView.js"],"names":[],"mappings":";AAuGA;IACI;;;;;OAKG;IACH,8CAHW,6BAA6B,EA6DvC;IAnDG,YAAgB;IAEhB,kBAAwB;IA4CxB,mBAAoB;CAM3B;iBAzKgB,2BAA2B;iBAI3B,2CAA2C"}

package/editor/view/library/mesh_library_drag.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {string} url
+ * @returns {string} the payload text to put on the drag
+ */
+export function encode_mesh_library_drag(url: string): string;
+/**
+ * The model a drop is carrying, or `""` when the drop is not ours — an empty payload, something
+ * another source put on the drag, or text that is not a payload at all. A drop handler is offered
+ * whatever the page was dragging, so "not ours" is an expected answer rather than a failure.
+ *
+ * @param {string} text as read back from the drag under {@link MESH_LIBRARY_DRAG_MIME}
+ * @returns {string} the model's url, or `""`
+ */
+export function decode_mesh_library_drag(text: string): string;
+/**
+ * The MIME type the mesh library's drag payload is carried under.
+ *
+ * @type {string}
+ */
+export const MESH_LIBRARY_DRAG_MIME: string;
+//# sourceMappingURL=mesh_library_drag.d.ts.map

package/editor/view/library/mesh_library_drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_library_drag.d.ts","sourceRoot":"","sources":["../../../../editor/view/library/mesh_library_drag.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,+CAHW,MAAM,GACJ,MAAM,CA+BlB;AA9DD;;;;GAIG;AACH,qCAFU,MAAM,CAEkC"}