@mavonengine/editor 0.0.8 → 0.0.10

package/dist/Editor/Network/NetworkOverlay.d.ts

@@ -0,0 +1,54 @@
+import type { ServerEntityView } from '@mavonengine/core/Networking/Client/NetworkManager';
+import type { SyncSnapshot } from '@mavonengine/core/Networking/Debug/sync';
+import EventEmitter from '@mavonengine/core/Utils/EventEmitter';
+import { Group } from 'three';
+import SyncStore from './SyncStore';
+export interface NetworkOverlayOptions {
+    /** A wireframe box per networked entity, where the server last said it is */
+    ghosts: boolean;
+    /** A ring around each player at the server's sync distance */
+    rings: boolean;
+    /** Colour the ghosts by what this player is sent, instead of by what any player is */
+    viewAs: string | null;
+}
+export type GhostState = 'synced' | 'stale' | 'untracked';
+export declare const GHOST_COLORS: Record<GhostState, number>;
+/**
+ * How a ghost is coloured: by the server's sync when it is known, otherwise by what this client last received.
+ */
+export declare function ghostState(view: ServerEntityView, newestTick: number | null, sync?: SyncSnapshot, viewAs?: string | null): GhostState;
+/**
+ * Draws the network state into the editor's viewport: where the server says each entity is (ghosts)
+ * and how far each player's state sync reaches (rings).
+ *
+ * Triggers `changed` when its options change.
+ */
+export default class NetworkOverlay extends EventEmitter {
+    readonly sync: SyncStore;
+    readonly group: Group<import("three").Object3DEventMap>;
+    private _options;
+    private ghosts;
+    private rings;
+    private unsubscribe?;
+    private boxGeometry;
+    private ringGeometry;
+    private materials;
+    private errorMaterial;
+    private ringMaterial;
+    private ringSelectedMaterial;
+    constructor(sync?: SyncStore, options?: NetworkOverlayOptions);
+    get options(): Readonly<NetworkOverlayOptions>;
+    setOptions(options: Partial<NetworkOverlayOptions>): void;
+    private get active();
+    private applyOptions;
+    update(): void;
+    private updateGhosts;
+    private createGhost;
+    private updateRings;
+    /** How many ghosts and rings are drawn */
+    get counts(): {
+        ghosts: number;
+        rings: number;
+    };
+    dispose(): void;
+}

package/dist/Editor/Network/SyncStore.d.ts

@@ -0,0 +1,22 @@
+import type { SyncSnapshot } from '@mavonengine/core/Networking/Debug/sync';
+export interface SyncState {
+    /** The server's state sync, undefined until the first answer or after a failed one */
+    sync?: SyncSnapshot;
+    error?: string;
+}
+/**
+ * The server's state sync, asked for a few times a second while something listens: the sync overlay or the Network panel.
+ */
+export default class SyncStore {
+    private intervalMs;
+    private load;
+    private state;
+    private listeners;
+    private timer?;
+    private loading;
+    constructor(intervalMs?: number, load?: () => Promise<SyncSnapshot>);
+    /** Stable until the next answer, for `useSyncExternalStore` */
+    get: () => SyncState;
+    subscribe: (listener: () => void) => (() => void);
+    refresh(): Promise<void>;
+}

package/dist/Editor/Network/serverApi.d.ts

@@ -0,0 +1,14 @@
+import type { NetRecordDetail, NetRecordList, NetRecordQuery } from '@mavonengine/core/Networking/Debug/NetRecorder';
+import type { SyncSnapshot } from '@mavonengine/core/Networking/Debug/sync';
+/**
+ * The game server's network debug endpoints (GET /api/game/dev/net/*), read by the editor.
+ *
+ * They are asked on the page's own origin, which is where the game server serves the client in dev.
+ * For a client served elsewhere, put the server's URL in `localStorage['mavonengine:server-url']`;
+ * the server then has to allow that origin (CORS).
+ */
+export declare const SERVER_URL_KEY = "mavonengine:server-url";
+export declare function serverUrl(): string;
+export declare function fetchSync(fetchFn?: typeof fetch): Promise<SyncSnapshot>;
+export declare function fetchPackets(query: NetRecordQuery, fetchFn?: typeof fetch): Promise<NetRecordList>;
+export declare function fetchPacket(id: number, fetchFn?: typeof fetch): Promise<NetRecordDetail | null>;

package/dist/Editor/Plugins/pluginsApi.d.ts

@@ -0,0 +1,49 @@
+import type { InstallJob, InstallStatus } from '@mavonengine/core/Plugins/install';
+import type { AvailablePlugin } from '@mavonengine/core/Plugins/registry';
+import type { PluginInfo, PluginInfoList } from '@mavonengine/core/Plugins/types';
+export type { AvailablePlugin, InstallJob, InstallStatus, PluginInfo, PluginInfoList };
+/** Put a URL here in localStorage to read the list of available plugins from a fork or a branch */
+export declare const PLUGINS_URL_KEY = "mavonengine:plugins-url";
+export declare function registryUrl(): string;
+/**
+ * The plugins that can be installed and the project doesn't have yet: plugins.json on the main branch of the
+ * MavonEngine repository, read from GitHub by the browser.
+ */
+export declare function fetchAvailablePlugins(installed: PluginInfo[], fetchFn?: typeof fetch): Promise<AvailablePlugin[]>;
+/**
+ * The plugins in the project's mavonengine.json, as the dev server describes them: version, readme, prefabs.
+ * Asked on the page's own origin, which the Vite dev server with `mavonEnginePlugins()` answers.
+ */
+export declare function fetchPlugins(fetchFn?: typeof fetch): Promise<PluginInfoList>;
+export interface PluginPrefab {
+    name: string;
+    /** Shown in the editor's asset list, when the plugin registered the prefab in this session */
+    label?: string;
+    /** Registered by the plugin's client entry right now, so it can be placed */
+    registered: boolean;
+    /** Listed under the plugin's `prefabs` in mavonengine.json: its assets ship in a release */
+    used: boolean;
+}
+/**
+ * The prefabs of a plugin: the ones it registered in the running editor, plus the ones its manifest or
+ * the project's mavonengine.json name
+ */
+export declare function pluginPrefabs(plugin: PluginInfo, registered: {
+    name: string;
+    label?: string;
+    plugin?: string;
+}[]): PluginPrefab[];
+/**
+ * The README of a plugin that isn't installed, read from the URL the list gives for it
+ */
+export declare function fetchAvailableReadme(plugin: AvailablePlugin, fetchFn?: typeof fetch): Promise<string>;
+/**
+ * Whether packages can be installed from the editor, and how the running or last install goes.
+ * Never throws: a dev server that can't be asked can't install either.
+ */
+export declare function fetchInstallStatus(fetchFn?: typeof fetch): Promise<InstallStatus>;
+/**
+ * Ask the dev server to install `packages`. It hands that to `mavonengine dev`, which installs them, adds the
+ * plugins among them to mavonengine.json and restarts the dev servers. Resolves once the install has started.
+ */
+export declare function startInstall(packages: string[], fetchFn?: typeof fetch): Promise<InstallJob>;

package/dist/Editor/Server/routesApi.d.ts

@@ -0,0 +1,23 @@
+import type { HttpRouteInfo } from '@mavonengine/core/Networking/Server/Http/RouteInfo';
+export type { HttpRouteInfo };
+/**
+ * The game server's list of HTTP endpoints (GET /api/game/routes), read by the editor's Server panel.
+ *
+ * It is asked on the page's own origin, which is where the game server serves the client in dev.
+ * For a client served elsewhere, put the server's URL in `localStorage['mavonengine:server-url']`;
+ * the server then has to allow that origin (CORS).
+ */
+export declare const SERVER_URL_KEY = "mavonengine:server-url";
+export declare function serverUrl(): string;
+export declare function fetchRoutes(fetchFn?: typeof fetch): Promise<HttpRouteInfo[]>;
+export interface RouteGroup {
+    /** `engine`, `game` or the plugin's package */
+    id: string;
+    /** `Engine`, `Game` or the plugin's package, as shown in the From column */
+    from: string;
+    routes: HttpRouteInfo[];
+}
+/**
+ * Routes by who registered them: the game's own first, then each plugin, the engine's last
+ */
+export declare function groupRoutes(routes: HttpRouteInfo[]): RouteGroup[];

package/dist/Editor/UI/ActivityBar.d.ts

@@ -1 +1,6 @@
-export default function ActivityBar(): import("react/jsx-runtime").JSX.Element;
+/** What the editor shows next to the activity bar: the scene editor itself, or a view that takes its place */
+export type Activity = 'scene' | 'server' | 'plugins';
+export default function ActivityBar({ active, onSelect }: {
+    active: Activity;
+    onSelect(activity: Activity): void;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Assets/AssetStats.d.ts

@@ -2,7 +2,7 @@ interface Stat {
     label: string;
     value: string;
 }
-declare const _default: ({ stats }: {
-    stats: Stat[];
-}) => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default({ stats }: {
+    stats: Stat[];
+}): import("react").JSX.Element;

package/dist/Editor/UI/Assets/Assets.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default(): import("react").JSX.Element;

package/dist/Editor/UI/Assets/AudioPlayer.d.ts

@@ -1,5 +1,5 @@
 interface Props {
     buffer: AudioBuffer;
 }
-declare const _default: ({ buffer }: Props) => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default({ buffer }: Props): import("react").JSX.Element;

package/dist/Editor/UI/Assets/ModelViewer.d.ts

@@ -1,6 +1,6 @@
 import type { AnimationClip, Object3D } from 'three';
-declare const _default: ({ model, animations }: {
+export default _default;
+declare function _default({ model, animations }: {
     model: Object3D;
     animations?: AnimationClip[];
-}) => import("react/jsx-runtime").JSX.Element;
-export default _default;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Assets/ParticleViewer.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ({ particleName }: {
-    particleName: string;
-}) => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default({ particleName }: {
+    particleName: string;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Assets/TextureViewer.d.ts

@@ -1,7 +1,7 @@
 import type { CubeTexture, Texture } from 'three';
 export type RawImage = HTMLImageElement | HTMLCanvasElement | ImageBitmap;
 export declare function getTextureUrl(texture: Texture<RawImage> | CubeTexture<HTMLImageElement>): string;
-declare const _default: ({ texture }: {
-    texture: Texture<RawImage> | CubeTexture<HTMLImageElement>;
-}) => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default({ texture }: {
+    texture: Texture<RawImage> | CubeTexture<HTMLImageElement>;
+}): import("react").JSX.Element;

package/dist/Editor/UI/CanvasPanel.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => import("react/jsx-runtime").JSX.Element;
 export default _default;
+declare function _default(): import("react").JSX.Element;

package/dist/Editor/UI/CanvasToolbar.d.ts

@@ -4,4 +4,4 @@ export declare const SHADE_MODES: {
     label: string;
     paths: string[];
 }[];
-export default function CanvasToolbar(): import("react/jsx-runtime").JSX.Element;
+export default function CanvasToolbar(): import("react").JSX.Element;

package/dist/Editor/UI/Controllers/ControllerDebug.d.ts

@@ -0,0 +1 @@
+export default function ControllerDebug(): import("react").JSX.Element;

package/dist/Editor/UI/Controllers/GamepadDiagram.d.ts

@@ -0,0 +1,5 @@
+import type { GamepadState } from '@mavonengine/core/GamepadManager';
+export default function GamepadDiagram({ gamepad, deadzone }: {
+    gamepad: GamepadState;
+    deadzone: number;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Controllers/useGamepads.d.ts

@@ -0,0 +1,6 @@
+import type { GamepadState } from '@mavonengine/core/GamepadManager';
+/**
+ * Connected controllers from the running game.
+ * Re-renders on connect / disconnect, and every animation frame when `live` is set.
+ */
+export declare function useGamepads(live?: boolean): GamepadState[];

package/dist/Editor/UI/DockArea.d.ts

@@ -0,0 +1,17 @@
+import type { EditorPanelLocation } from '@mavonengine/core/Types/IEditor';
+import type { ReactNode } from 'react';
+export interface BuiltinPanel {
+    id: string;
+    title: string;
+    element: ReactNode;
+    /** Wrap in the padded, scrolling panel body. Default true */
+    padded?: boolean;
+}
+/**
+ * One dock of the editor (left, bottom or right): its built-in panels and the custom ones registered for it, as tabs.
+ * Built-in panels stay mounted while hidden so they keep their state; custom panels mount when their tab is shown.
+ */
+export default function DockArea({ location, builtins }: {
+    location: EditorPanelLocation;
+    builtins: BuiltinPanel[];
+}): import("react").JSX.Element;

package/dist/Editor/UI/Editor.d.ts

@@ -1,3 +1,3 @@
 import './global.css';
-declare function Editor(): import("react/jsx-runtime").JSX.Element;
+declare function Editor(): import("react").JSX.Element;
 export default Editor;

package/dist/Editor/UI/Network/NetworkPanel.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The editor's Network panel: packets and network events of the server or of this tab, a timeline of them,
+ * the server's state sync, and the switches of the viewport overlay.
+ */
+export default function NetworkPanel(): import("react").JSX.Element;

package/dist/Editor/UI/Network/Timeline.d.ts

@@ -0,0 +1,14 @@
+import type { NetRecord } from '@mavonengine/core/Networking/Debug/NetRecorder';
+declare const LANES: readonly ['out', 'in', 'event'];
+export declare function laneOf(record: NetRecord): typeof LANES[number];
+/**
+ * The last `windowMs` of traffic as marks on three lanes: sent, received and events. Taller marks are larger packets.
+ * While `live` the newest moment sits at the right edge and the marks scroll; paused it ends at the last record.
+ */
+export default function Timeline({ records, selectedId, live, windowMs }: {
+    records: NetRecord[];
+    selectedId?: number;
+    live: boolean;
+    windowMs?: number;
+}): import("react").JSX.Element;
+export {};

package/dist/Editor/UI/Network/format.d.ts

@@ -0,0 +1,14 @@
+import type { NetRecord } from '@mavonengine/core/Networking/Debug/NetRecorder';
+export declare function formatBytes(bytes: number | undefined): string;
+/** Local time with milliseconds, e.g. 14:02:11.123 */
+export declare function formatTime(timestamp: number): string;
+/** The facts of a record in one line: tick, sequence id and what `info` holds */
+export declare function describeRecord(record: NetRecord): string;
+export interface RecordFilter {
+    kind: 'all' | 'packet' | 'event';
+    /** ping / pong: one pair a second per client */
+    pings: boolean;
+    /** Part of the message name or the peer, case-insensitive */
+    text: string;
+}
+export declare function filterRecords(records: NetRecord[], { kind, pings, text }: RecordFilter): NetRecord[];

package/dist/Editor/UI/Network/useRecords.d.ts

@@ -0,0 +1,13 @@
+import type { NetRecord, NetRecordDetail } from '@mavonengine/core/Networking/Debug/NetRecorder';
+/** Whose records are shown: everything the server sent and received, or only this tab's own traffic */
+export type RecordSource = 'server' | 'client';
+/**
+ * The newest records of one side, oldest first, kept up to date while not paused
+ */
+export declare function useRecords(source: RecordSource, paused: boolean): {
+    records: NetRecord[];
+    error: string | undefined;
+    clear: () => void;
+};
+/** One record with its payload, undefined while it loads or when nothing is selected */
+export declare function useRecordDetail(source: RecordSource, id: number | undefined): NetRecordDetail | null | undefined;

package/dist/Editor/UI/PanelHeader.d.ts

@@ -1,3 +1,3 @@
 export default function PanelHeader({ title }: {
     title: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Plugins/InstallDialog.d.ts

@@ -0,0 +1,22 @@
+/** How often the install is asked about while it runs */
+export declare const INSTALL_POLL_MS = 1000;
+export interface InstallRequest {
+    /** What is handed to the package manager: names, name@version, file: paths, URLs */
+    packages: string[];
+    /** Where the source can be looked at, when the list of plugins says */
+    homepage?: string;
+}
+/** Where to look at what `spec` installs: the list's homepage, the URL itself, or its page on npm */
+export declare function sourceOf(spec: string, homepage?: string): string | undefined;
+/**
+ * Asks before anything is installed, then shows how the install goes.
+ *
+ * A package runs its own code on the machine, when it is installed and whenever the game runs, and nothing
+ * checks what it does. So the dialog says so, points at the source and only installs once the person
+ * has ticked that they looked at it.
+ */
+export default function InstallDialog({ request, onClose, fetchFn }: {
+    request: InstallRequest;
+    onClose(): void;
+    fetchFn?: typeof fetch;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Plugins/Markdown.d.ts

@@ -0,0 +1,3 @@
+export default function Markdown({ source }: {
+    source: string;
+}): import("react").JSX.Element;

package/dist/Editor/UI/Plugins/PluginsPanel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The plugins in the project's mavonengine.json: what each is, and which HTTP endpoints and prefabs come from it.
+ * Plugin details come from the dev server, endpoints from the game server, prefabs from the running editor.
+ * Below them, the plugins that can be installed: the public list on GitHub, without the ones the project has.
+ */
+export default function PluginsPanel({ fetchFn }: {
+    fetchFn?: typeof fetch;
+}): import("react").JSX.Element;

package/dist/Editor/UI/PropertiesPanel.d.ts

@@ -1 +1 @@
-export default function PropertiesPanel(): import("react/jsx-runtime").JSX.Element;
+export default function PropertiesPanel(): import("react").JSX.Element;

package/dist/Editor/UI/SceneExplorer.d.ts

@@ -1 +1 @@
-export default function SceneExplorer(): import("react/jsx-runtime").JSX.Element;
+export default function SceneExplorer(): import("react").JSX.Element;

package/dist/Editor/UI/ScenePanel.d.ts

@@ -0,0 +1 @@
+export default function ScenePanel(): import("react").JSX.Element;

package/dist/Editor/UI/Server/ServerPanel.d.ts

@@ -0,0 +1,9 @@
+/** How often the list is read again while the panel is shown */
+export declare const ROUTES_REFRESH_MS = 5000;
+/**
+ * The game server's HTTP endpoints: the engine's, the game's own and those of plugins.
+ * Read from the running server, so it shows what the server answers right now.
+ */
+export default function ServerPanel({ fetchFn }: {
+    fetchFn?: typeof fetch;
+}): import("react").JSX.Element;

package/dist/Editor/UI/ShadeModeButtons.d.ts

@@ -6,5 +6,5 @@ interface Props {
     activeClass: string;
     size?: number;
 }
-export default function ShadeModeButtons({ shadeMode, onChange, btnClass, activeClass, size }: Props): import("react/jsx-runtime").JSX.Element;
+export default function ShadeModeButtons({ shadeMode, onChange, btnClass, activeClass, size }: Props): import("react").JSX.Element;
 export {};

package/dist/Editor/UI/StatusBar.d.ts

@@ -1 +1 @@
-export default function StatusBar(): import("react/jsx-runtime").JSX.Element;
+export default function StatusBar(): import("react").JSX.Element;

package/dist/Editor/UI/TabBar.d.ts

@@ -1 +1 @@
-export default function TabBar(): import("react/jsx-runtime").JSX.Element;
+export default function TabBar(): import("react").JSX.Element;

package/dist/Editor/UI/Window.d.ts

@@ -11,5 +11,5 @@ interface Props {
     storageKey?: string;
     onClose(): void;
 }
-declare const _default: ({ title, children, defaultX, defaultY, defaultWidth, defaultHeight, minWidth, minHeight, storageKey, onClose }: Props) => import("react").ReactPortal;
 export default _default;
+declare function _default({ title, children, defaultX, defaultY, defaultWidth, defaultHeight, minWidth, minHeight, storageKey, onClose }: Props): import("react").ReactPortal;

package/dist/Editor/builtinPrefabs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Register the prefabs that come with the engine. Plugins add theirs with `ctx.registerPrefab()`.
+ */
+export declare function registerBuiltinPrefabs(): void;

package/dist/Editor/demoScene.d.ts

@@ -0,0 +1,7 @@
+import type { SceneData } from '@mavonengine/core/Scene/types';
+/** The scene the editor opens and saves when the game loaded none */
+export declare const DEFAULT_SCENE_NAME = "main";
+/**
+ * Some shapes on a ground plane, to have something to look at in a new project
+ */
+export declare function demoScene(): SceneData;

package/dist/Editor/panels.d.ts

@@ -0,0 +1,22 @@
+import type { EditorPanel, EditorPanelLocation } from '@mavonengine/core/Types/IEditor';
+import type IEditor from '@mavonengine/core/Types/IEditor';
+import type { ComponentType } from 'react';
+export type { EditorPanelLocation };
+/**
+ * A panel for the editor. Same as core's `EditorPanel`, with `component` typed as a React component.
+ */
+export interface EditorPanelDefinition extends Omit<EditorPanel, 'component'> {
+    component?: ComponentType<{
+        editor: IEditor;
+    }>;
+}
+/**
+ * Dock a panel in the editor. Works before the editor boots too, e.g. next to `Editor.registerListener()`.
+ * Returns a function that removes it again.
+ */
+export declare function registerEditorPanel(panel: EditorPanelDefinition | EditorPanel): () => void;
+export declare function unregisterEditorPanel(id: string): void;
+/** Every registered panel, for `useSyncExternalStore` */
+export declare function getEditorPanels(): EditorPanelDefinition[];
+export declare function subscribeEditorPanels(listener: () => void): () => void;
+export declare function panelsAt(all: EditorPanelDefinition[], location: EditorPanelLocation): EditorPanelDefinition[];

package/dist/Editor/recordPrefabUsage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tell the dev server that the project uses a plugin prefab, so its assets ship in the release.
+ * The server adds it to the plugin's `prefabs` in mavonengine.json. Sent once per prefab per session.
+ */
+export declare function recordPrefabUsage(plugin: string, prefab: string, fetchFn?: typeof fetch): Promise<void>;
+/** For tests */
+export declare function resetRecordedPrefabs(): void;