@java-memory-playground/java-memory-playground 0.2.0

package/dist/javaSource.d.ts

@@ -0,0 +1,17 @@
+import { Klasses } from "./memory";
+/**
+ * Reads the class structure out of Java source.
+ *
+ * Only declarations are read — class names, and the name and type of each
+ * field. Method bodies are skipped wholesale and nothing is executed or
+ * interpreted: the source is a convenient way to write down the shape of the
+ * objects a diagram will contain, not a program the playground runs.
+ */
+export type ParsedClasses = {
+    klasses: Klasses;
+    /** Things the teacher probably wants to know about, in reading order. */
+    problems: string[];
+};
+export declare const parseJavaClasses: (source: string) => ParsedClasses;
+/** Writes the current classes back out as Java, for editing as source. */
+export declare const toJavaSource: (klasses: Klasses) => string;

package/dist/klassImpact.d.ts

@@ -0,0 +1,28 @@
+import { Klasses } from "./memory";
+import { CustomEdgeType, CustomNodeType } from "./types";
+/**
+ * What applying a set of classes would cost the objects already drawn.
+ *
+ * Classes belong to the whole diagram, so changing them reaches every step. A
+ * teacher pasting a new file over the old one should be told what that takes
+ * with it before it happens — but only when it takes something, because a
+ * warning that always appears is one nobody reads.
+ */
+export type KlassImpact = {
+    /** Objects of a class that is gone. They stay; no new ones can be made. */
+    orphaned: Array<{
+        klass: string;
+        count: number;
+    }>;
+    /** Values and references a removed field takes with it. */
+    dropped: Array<{
+        klass: string;
+        field: string;
+        count: number;
+    }>;
+};
+export declare const klassImpact: (steps: Array<{
+    nodes: CustomNodeType[];
+    edges: CustomEdgeType[];
+}>, klasses: Klasses) => KlassImpact;
+export declare const hasImpact: ({ orphaned, dropped }: KlassImpact) => boolean;

package/dist/memory.d.ts

@@ -0,0 +1,152 @@
+export declare const numericDataTypes: string[];
+/**
+ * The eight-ish types whose value really is stored in the variable itself.
+ *
+ * `String` is deliberately NOT here: in Java it is a reference type, and a
+ * String value lives on the heap like any other object. Drawing every String as
+ * its own box clutters a diagram whose lesson is elsewhere, so the playground
+ * collapses them by default — but that is a display choice (`options.
+ * inlineStrings`), not a claim about how memory works.
+ */
+export declare const primitveDataTypes: string[];
+/** The class name of the heap objects that hold String values. */
+export declare const STRING_KLASS = "String";
+/** Types always offered in a type picker, before the user's own classes. */
+export declare const builtInDataTypes: string[];
+/**
+ * What a field of this type holds before anyone has put anything in it.
+ *
+ * A reference starts out null, which the diagram draws as an empty handle
+ * rather than a value, so it has none.
+ */
+export declare const defaultValueFor: (dataType: string) => Attribute["value"];
+export type DataType = "int" | "long" | "short" | "byte" | "float" | "char" | "double" | "boolean" | "String" | "Array" | string;
+export interface KlassAttributes {
+    [key: string]: DataType;
+}
+export type Klass = {
+    attributes: KlassAttributes;
+};
+export type Attribute = {
+    dataType: DataType;
+    value?: string | number | boolean;
+};
+export interface ObjAttributes {
+    [key: string]: Attribute;
+}
+export type Obj = {
+    klass: string;
+    attributes: ObjAttributes;
+    position: {
+        x: number;
+        y: number;
+    };
+    arrayElementType?: DataType;
+    /**
+     * The characters held by a String object (`klass === STRING_KLASS`), without
+     * surrounding quotes — those are added when rendering.
+     */
+    literal?: string;
+};
+export type Variable = {
+    name: string;
+    dataType: DataType;
+    value: string | null;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+export interface localVariables {
+    [key: string]: Attribute;
+}
+export type MethodCall = {
+    name: string;
+    index: number;
+    localVariables: localVariables;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+export interface Klasses {
+    [key: string]: Klass;
+}
+export interface Objs {
+    [key: string]: Obj;
+}
+export interface Variables {
+    [key: string]: Variable;
+}
+export interface MethodCalls {
+    [key: number]: MethodCall;
+}
+/**
+ * One state of the diagram: the heap, the roots and the call stack at a single
+ * moment. A diagram is a sequence of these, so that a stack can be shown doing
+ * the thing that makes it a stack — growing and shrinking over time.
+ */
+export type Step = {
+    /** Shown in the step bar, e.g. "3: head = head.next". */
+    label?: string;
+    /** The teacher's note about what this step did. */
+    note?: string;
+    /**
+     * The student produces this step themselves. Its contents are the solution:
+     * a student's playground starts them from the previous step and checks what
+     * they build against it.
+     */
+    exercise?: boolean;
+    objects: Objs;
+    variables: Variables;
+    methodCalls: MethodCalls;
+};
+export type Memory = {
+    viewport: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    options: {
+        disableGarbageCollector?: boolean;
+        hideSidebar?: boolean;
+        hideCallMethod?: boolean;
+        hideDeclareGlobalVariable?: boolean;
+        hideNewArray?: boolean;
+        createNewOnEdgeDrop?: boolean;
+        /**
+         * Draw String values inside the object that references them instead of as
+         * their own heap box. On by default: a diagram about a linked list should
+         * not sprout a box per name. Turn it off to teach that a String is an
+         * object like any other — `==` versus `.equals()`, the string pool.
+         */
+        inlineStrings?: boolean;
+        /** Hide the step bar, for lessons that are about one picture. */
+        hideSteps?: boolean;
+        /**
+         * Stop marking what a step changed compared with the one before it. The
+         * marking is usually the point of a trace, so it is on by default.
+         */
+        hideStepChanges?: boolean;
+        /**
+         * Ask which objects are unreachable before collecting them, instead of
+         * simply sweeping. Committing to an answer is where the learning is.
+         */
+        gcPrediction?: boolean;
+    };
+    klasses: Klasses;
+    /**
+     * The steps of the diagram. `parseMemory` always fills this in, from the
+     * single-state fields below when a diagram predates stepping.
+     */
+    steps?: Step[];
+    /**
+     * The state of a one-step diagram. Still written for those, so that a link to
+     * a single picture stays readable by older versions, and still read from
+     * every diagram saved before steps existed.
+     */
+    objects?: Objs;
+    variables?: Variables;
+    methodCalls?: MethodCalls;
+};
+export declare const initialMemory: Memory;

package/dist/palette.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The handful of palette entries that have to exist in JavaScript as well as in
+ * CSS, named after the tokens in `index.css` they duplicate.
+ *
+ * Anything drawn into an `<svg>` or onto a canvas has to be a literal colour;
+ * `var(--jmp-…)` does not survive being photographed. html-to-image copies
+ * computed styles onto its clone but stops at an `<svg>`, taking that subtree
+ * wholesale, and then renders the clone outside `.java-memory-playground`,
+ * where the custom properties are not defined. An unresolvable `var()` is
+ * invalid at computed-value time, so `stroke` falls back to its initial `none`
+ * and a reference disappears from the picture — while its arrowhead, whose
+ * `fill` falls back to black, stays behind pointing at nothing. A canvas has no
+ * stylesheet to read at all.
+ *
+ * `palette.test.ts` keeps these in step with `index.css`, so a colour still
+ * only has to be changed in one place.
+ */
+/** `--jmp-black`. What print mode draws its references in. */
+export declare const BLACK = "#000000";
+/** `--jmp-text` — Coal. */
+export declare const TEXT = "#242428";
+/** `--jmp-text-muted` — Charcoal. */
+export declare const TEXT_MUTED = "#3c3c3c";
+/** `--jmp-surface` — White. */
+export declare const SURFACE = "#ffffff";
+/** `--jmp-surface-sunken` — Whitesmoke. */
+export declare const SURFACE_SUNKEN = "#f5f5f5";
+/** `--jmp-warning`. */
+export declare const WARNING = "#b7791f";

package/dist/presets.d.ts

@@ -0,0 +1,10 @@
+import { Memory } from "./memory";
+export type PresetName = "references" | "stack" | "everything";
+/**
+ * Option sets for the stages a course goes through.
+ *
+ * The options already describe a teaching sequence — references before the
+ * stack, arrays and the collector after — but only as flags a teacher has to
+ * remember the combination of. These name the combinations.
+ */
+export declare const optionPresets: Record<PresetName, Memory["options"]>;

package/dist/serde.d.ts

@@ -0,0 +1,4 @@
+type State = any;
+export declare const serializeState: (state: State) => string;
+export declare const deserializeState: (state: string) => State;
+export {};

package/dist/stepDiff.d.ts

@@ -0,0 +1,18 @@
+import { StoreStep } from "./store";
+export type StepDiff = {
+    /** Nodes that did not exist in the previous step. */
+    added: Set<string>;
+    /** Nodes whose contents differ from the previous step. */
+    changed: Set<string>;
+    /** Edges that are new, or that now point somewhere else. */
+    edges: Set<string>;
+};
+export declare const emptyDiff: () => StepDiff;
+/**
+ * What the current step changed, compared with the one before it.
+ *
+ * This is what turns a sequence of pictures into a story: the interesting part
+ * of a step is rarely the whole diagram, it is the one reference that moved or
+ * the one frame that appeared.
+ */
+export declare const diffSteps: (previous: StoreStep | undefined, current: StoreStep) => StepDiff;

package/dist/store.d.ts

@@ -0,0 +1,230 @@
+import type { EdgeChange, NodeChange, Viewport } from "@xyflow/react";
+import { ExerciseResult } from "./canonical";
+import { Memory } from "./memory";
+import { Translations } from "./translations";
+import { CustomEdgeType, CustomNodeType } from "./types";
+export type Route = "view" | "config";
+/**
+ * Who the playground is for.
+ *
+ * `view` is the student's playground: the whole diagram, every edit, steps to
+ * walk through. `edit` adds the teacher's tools on top — configuring classes
+ * and options, and authoring the steps of a trace.
+ */
+export type PlaygroundMode = "view" | "edit";
+/** One step, in the shape React Flow wants. */
+export type StoreStep = {
+    label?: string;
+    note?: string;
+    exercise?: boolean;
+    nodes: CustomNodeType[];
+    edges: CustomEdgeType[];
+};
+export type GcPredictionResult = {
+    /** Unreachable objects the prediction found. */
+    found: number;
+    /** Unreachable objects it missed. */
+    missed: number;
+    /** Objects it marked that are still reachable. */
+    wrong: number;
+};
+type Updater<T> = T[] | ((current: T[]) => T[]);
+export type RFState = {
+    route: Route;
+    mode: PlaygroundMode;
+    selectedNodeId: string;
+    /** Whether this store mirrors its memory into `location.hash`. */
+    persistence: boolean;
+    steps: StoreStep[];
+    currentStep: number;
+    klasses: Memory["klasses"];
+    options: Memory["options"];
+    viewport: Viewport;
+    /**
+     * The authored contents of the exercise steps, kept aside in a student's
+     * playground so that their attempt can be compared with it.
+     */
+    solutions: Record<number, StoreStep>;
+    exerciseResult: ExerciseResult | null;
+    /** Ids of the objects a prediction has marked as unreachable, while running. */
+    gcPrediction: string[] | null;
+    gcResult: GcPredictionResult | null;
+    defaultLanguage?: string;
+    /**
+     * Bumped every time the user presses Save. The diagram itself is kept in the
+     * store continuously; this is what tells a host "the user committed".
+     */
+    saveCount: number;
+    save: () => void;
+    goToStep: (index: number) => void;
+    addStep: () => void;
+    deleteStep: (index: number) => void;
+    setStepLabel: (index: number, label: string) => void;
+    /** The nodes and edges of the step on screen. */
+    getNodes: () => CustomNodeType[];
+    getEdges: () => CustomEdgeType[];
+    /** Reconciles every step's objects with a new set of class definitions. */
+    applyKlasses: (klasses: Memory["klasses"], options: Memory["options"]) => void;
+    setRoute: (route: Route) => void;
+    selectNodeId: (nodeId: string) => void;
+    setDefaultLanguage: (language: string) => void;
+    onNodesChange: (changes: NodeChange<CustomNodeType>[]) => void;
+    onEdgesChange: (changes: EdgeChange<CustomEdgeType>[]) => void;
+    setNodes: (nodes: Updater<CustomNodeType>) => void;
+    setEdges: (edges: Updater<CustomEdgeType>) => void;
+    setKlasses: (klasses: Memory["klasses"]) => void;
+    setOptions: (options: Memory["options"]) => void;
+    setViewport: (viewport: Viewport) => void;
+    setStepExercise: (index: number, exercise: boolean) => void;
+    checkExercise: () => void;
+    revealSolution: () => void;
+    clearExerciseResult: () => void;
+    startGcPrediction: () => void;
+    toggleGcPrediction: (id: string) => void;
+    cancelGcPrediction: () => void;
+    /** Checks a prediction if one is running, then collects. */
+    collectGarbage: () => void;
+    loadMemory: (memory: Memory) => void;
+    getMemory: () => Memory;
+    getLanguage: () => string;
+    getTranslations: () => Translations;
+};
+/**
+ * Set whether playgrounds created from now on mirror their state into
+ * `location.hash`. Off by default; the standalone web app turns it on during
+ * bootstrap. Embedded usages (React hosts, the web component) leave it off and
+ * drive state through the `memory` prop and the `change` event instead.
+ */
+export declare function setPersistence(enabled: boolean): void;
+/** The persistence setting new playgrounds are created with. */
+export declare function isPersistenceEnabled(): boolean;
+/**
+ * Creates an independent playground store.
+ *
+ * One store per `MemoryPlayground` instance, so that a page can host several
+ * playgrounds without them overwriting each other's diagrams.
+ */
+export declare const createMemoryStore: (persistence?: boolean, mode?: PlaygroundMode) => Omit<Omit<import("zustand").StoreApi<RFState>, "persist" | "setState"> & {
+    setState(partial: Partial<RFState> | RFState | ((state: RFState) => Partial<RFState> | RFState), replace?: false | undefined): unknown;
+    setState(state: RFState | ((state: RFState) => RFState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<RFState, any, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: RFState) => void) => () => void;
+        onFinishHydration: (fn: (state: RFState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<RFState, any, unknown>>;
+    };
+}, "temporal"> & {
+    temporal: import("zustand").StoreApi<import("zundo").TemporalState<{
+        steps: {
+            label: string | undefined;
+            note: string | undefined;
+            nodes: ({
+                [x: string]: unknown;
+                id: string;
+                position: import("@xyflow/react").XYPosition;
+                data: import("./memory").MethodCall;
+                sourcePosition?: import("@xyflow/react").Position;
+                targetPosition?: import("@xyflow/react").Position;
+                hidden?: boolean;
+                draggable?: boolean;
+                selectable?: boolean;
+                connectable?: boolean;
+                deletable?: boolean;
+                dragHandle?: string;
+                initialWidth?: number;
+                initialHeight?: number;
+                parentId?: string;
+                zIndex?: number;
+                extent?: 'parent' | import("@xyflow/react").CoordinateExtent | null;
+                expandParent?: boolean;
+                ariaLabel?: string;
+                origin?: import("@xyflow/react").NodeOrigin;
+                handles?: import("@xyflow/react").NodeHandle[];
+                type: "method-call";
+                style?: import("react").CSSProperties;
+                className?: string;
+                resizing?: boolean;
+                focusable?: boolean;
+                ariaRole?: import("react").AriaRole;
+                domAttributes?: Omit<import("react").HTMLAttributes<HTMLDivElement>, 'id' | 'style' | 'className' | 'draggable' | 'role' | 'aria-label' | 'defaultValue' | 'dangerouslySetInnerHTML' | keyof import("react").DOMAttributes<HTMLDivElement>>;
+            } | {
+                [x: string]: unknown;
+                id: string;
+                position: import("@xyflow/react").XYPosition;
+                data: import("./memory").Obj;
+                sourcePosition?: import("@xyflow/react").Position;
+                targetPosition?: import("@xyflow/react").Position;
+                hidden?: boolean;
+                draggable?: boolean;
+                selectable?: boolean;
+                connectable?: boolean;
+                deletable?: boolean;
+                dragHandle?: string;
+                initialWidth?: number;
+                initialHeight?: number;
+                parentId?: string;
+                zIndex?: number;
+                extent?: 'parent' | import("@xyflow/react").CoordinateExtent | null;
+                expandParent?: boolean;
+                ariaLabel?: string;
+                origin?: import("@xyflow/react").NodeOrigin;
+                handles?: import("@xyflow/react").NodeHandle[];
+                type: "object";
+                style?: import("react").CSSProperties;
+                className?: string;
+                resizing?: boolean;
+                focusable?: boolean;
+                ariaRole?: import("react").AriaRole;
+                domAttributes?: Omit<import("react").HTMLAttributes<HTMLDivElement>, 'id' | 'style' | 'className' | 'draggable' | 'role' | 'aria-label' | 'defaultValue' | 'dangerouslySetInnerHTML' | keyof import("react").DOMAttributes<HTMLDivElement>>;
+            } | {
+                [x: string]: unknown;
+                id: string;
+                position: import("@xyflow/react").XYPosition;
+                data: import("./memory").Variable;
+                sourcePosition?: import("@xyflow/react").Position;
+                targetPosition?: import("@xyflow/react").Position;
+                hidden?: boolean;
+                draggable?: boolean;
+                selectable?: boolean;
+                connectable?: boolean;
+                deletable?: boolean;
+                dragHandle?: string;
+                initialWidth?: number;
+                initialHeight?: number;
+                parentId?: string;
+                zIndex?: number;
+                extent?: 'parent' | import("@xyflow/react").CoordinateExtent | null;
+                expandParent?: boolean;
+                ariaLabel?: string;
+                origin?: import("@xyflow/react").NodeOrigin;
+                handles?: import("@xyflow/react").NodeHandle[];
+                type: "variable";
+                style?: import("react").CSSProperties;
+                className?: string;
+                resizing?: boolean;
+                focusable?: boolean;
+                ariaRole?: import("react").AriaRole;
+                domAttributes?: Omit<import("react").HTMLAttributes<HTMLDivElement>, 'id' | 'style' | 'className' | 'draggable' | 'role' | 'aria-label' | 'defaultValue' | 'dangerouslySetInnerHTML' | keyof import("react").DOMAttributes<HTMLDivElement>>;
+            })[];
+            edges: CustomEdgeType[];
+        }[];
+        klasses: import("./memory").Klasses;
+        options: {
+            disableGarbageCollector?: boolean;
+            hideSidebar?: boolean;
+            hideCallMethod?: boolean;
+            hideDeclareGlobalVariable?: boolean;
+            hideNewArray?: boolean;
+            createNewOnEdgeDrop?: boolean;
+            inlineStrings?: boolean;
+            hideSteps?: boolean;
+            hideStepChanges?: boolean;
+            gcPrediction?: boolean;
+        };
+    }>>;
+};
+export type MemoryStore = ReturnType<typeof createMemoryStore>;
+export {};

package/dist/storeContext.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import type { TemporalState } from "zundo";
+import { MemoryStore, PlaygroundMode, RFState } from "./store";
+export declare const StoreProvider: ({ persistence, mode, children, }: {
+    persistence?: boolean;
+    mode?: PlaygroundMode;
+    children: ReactNode;
+}) => import("react").JSX.Element;
+/**
+ * Reads from the store of the surrounding `MemoryPlayground`.
+ *
+ * For a selector that builds an object, wrap it in zustand's `useShallow` so
+ * the component only re-renders when one of the picked values actually changes.
+ */
+export declare function useStore<U>(selector: (state: RFState) => U): U;
+/** The raw store instance, for reading or subscribing outside of React. */
+export declare function useMemoryStore(): MemoryStore;
+/**
+ * Reads the undo/redo history of the surrounding `MemoryPlayground`.
+ *
+ * `undo`, `redo`, `pastStates` and `futureStates` come from zundo.
+ */
+export declare function useTemporalStore<U>(selector: (state: TemporalState<Partial<RFState>>) => U): U;
+export default useStore;

package/dist/translations.d.ts

@@ -0,0 +1,119 @@
+export interface Translations {
+    save: string;
+    saveUrl: string;
+    downloadPng: string;
+    downloadAllPng: string;
+    downloadAllPngHint: string;
+    printMode: string;
+    printModeHint: string;
+    config: string;
+    runGarbageCollector: string;
+    predictGarbage: string;
+    predictGarbageHint: (marked: number) => string;
+    checkAndCollect: string;
+    gcScore: (found: number, missed: number, wrong: number) => string;
+    undo: string;
+    redo: string;
+    help: string;
+    newInstanceOf: (klass: string) => string;
+    newArray: string;
+    callMethod: string;
+    declareGlobalVariable: string;
+    previousStep: string;
+    nextStep: string;
+    addStep: string;
+    addStepHint: string;
+    deleteStep: string;
+    stepLabel: string;
+    stepLabelPlaceholder: string;
+    exerciseStep: string;
+    exerciseStepHint: string;
+    yourTurn: string;
+    checkAnswer: string;
+    showSolution: string;
+    exerciseCorrect: string;
+    exerciseWrong: (wrong: string[]) => string;
+    exerciseExtra: (extra: string[]) => string;
+    declareLocalVariable: string;
+    returnMethod: string;
+    returnOnlyTopOfStack: string;
+    ok: string;
+    cancel: string;
+    createMethodCall: string;
+    methodName: string;
+    methodNamePlaceholder: string;
+    createGlobalVariable: string;
+    variableName: string;
+    variableNamePlaceholder: string;
+    createObject: (type: string) => string;
+    objectName: string;
+    createArray: string;
+    arrayLength: string;
+    arrayElementType: string;
+    declareLocalVariableTitle: string;
+    configuration: string;
+    classes: string;
+    addClass: string;
+    className: string;
+    classNamePlaceholder: string;
+    attributes: string;
+    addAttribute: string;
+    attributeName: string;
+    dataType: string;
+    classSource: string;
+    classList: string;
+    classSourceHint: string;
+    classSourcePlaceholder: string;
+    options: string;
+    presets: string;
+    presetReferences: string;
+    presetStack: string;
+    presetEverything: string;
+    backToDiagram: string;
+    saved: string;
+    unsavedChangesLeave: string;
+    confirmDeleteClass: (name: string) => string;
+    applyClassesTitle: string;
+    applyClassesIntro: string;
+    applyClassesDropped: (klass: string, field: string, count: number) => string;
+    applyClassesOrphaned: (klass: string, count: number) => string;
+    applyClassesMore: (count: number) => string;
+    applyClassesConfirm: string;
+    /**
+     * React Flow's own accessible descriptions, which it ships in English only.
+     * A German playground was reading them out in English next to its own
+     * translated labels; they are handed back through `ariaLabelConfig`.
+     */
+    a11y: {
+        node: string;
+        nodeKeyboard: string;
+        nodeMoved: (direction: string, x: number, y: number) => string;
+        edge: string;
+        controls: string;
+        zoomIn: string;
+        zoomOut: string;
+        fitView: string;
+        toggleInteractivity: string;
+        handle: string;
+    };
+    optionLabels: {
+        hideSidebar: string;
+        hideCallMethod: string;
+        hideDeclareGlobalVariable: string;
+        hideNewArray: string;
+        disableGarbageCollector: string;
+        createNewOnEdgeDrop: string;
+        inlineStrings: string;
+        hideSteps: string;
+        hideStepChanges: string;
+        gcPrediction: string;
+    };
+}
+export declare const translations: Record<string, Translations>;
+/**
+ * Detects the user's browser language and returns a supported language code.
+ * Falls back to 'en' if the browser language is not supported.
+ */
+export declare function detectBrowserLanguage(): string;
+export declare function getLanguage(explicitLanguage?: string): string;
+export declare function getTranslations(language?: string): Translations;

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type { BuiltInEdge } from "@xyflow/react";
+import { ObjectNodeType } from "./ObjectNode";
+import { VariableNode } from "./VariableNode";
+import { MethodCallNodeType } from "./MethodCallNode";
+import { ReferenceEdge } from "./ReferenceEdge";
+export type CustomNodeType = ObjectNodeType | VariableNode | MethodCallNodeType;
+export type CustomEdgeType = BuiltInEdge | ReferenceEdge;
+export interface KeyBinding {
+    key: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+}
+export interface KeyBindings {
+    save: KeyBinding;
+    undo: KeyBinding;
+    redo: KeyBinding;
+    toggleConfig: KeyBinding;
+    zoomIn: KeyBinding;
+    zoomOut: KeyBinding;
+    resetZoom: KeyBinding;
+    fitView: KeyBinding;
+}