@kubohiroya/turbowarp-extension-data-editor 0.7.0 → 0.8.1

package/dist/turbowarp/fixed-fields.d.ts

@@ -1,82 +1,67 @@
+import type { FixedInputMetadata } from '../fixed-input-types.js';
+import type { ArgumentSlot } from '../types.js';
+import type { Identify, NativeBlock, NativeField, NativeFieldClass, NativeScratchBlocks, NativeTarget, VMBlock } from './native-types.js';
+export interface FieldBinding {
+    block: NativeBlock;
+    field: NativeField;
+    fieldName: string;
+    value: string;
+    vmBlock: VMBlock;
+    kind: 'text' | 'number' | 'menu' | 'color';
+    Class: NativeFieldClass;
+    prototype: object;
+    allowedValues: readonly string[] | null | undefined;
+    restoreValue: NativeField['setValue'];
+    rawState: PropertyState[];
+    restoreHandles(): void;
+    restoreDom(): void;
+    restoreState?: ReturnType<typeof colorState>;
+}
+interface Inspection {
+    slot: ArgumentSlot;
+    metadata: FixedInputMetadata;
+    signatureParts: unknown[];
+    binding?: FieldBinding;
+}
+type PropertyState = [name: string, descriptor: PropertyDescriptor | undefined];
 /** Freeze native method identities once when the host attaches, before opening editors. */
-export function initializeFixedFields(ScratchBlocks: any): void;
+export declare function initializeFixedFields(ScratchBlocks: NativeScratchBlocks): void;
+declare const colorState: (block: NativeBlock, field: NativeField) => {
+    colors: unknown[];
+    hsv: unknown[][];
+    blockProperties: PropertyState[];
+};
 /** Native objects stay local; only primitive metadata is returned in snapshots. */
-export function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, argument, role, identify, extensionId }: {
-    ScratchBlocks: any;
-    block: any;
-    vmBlock: any;
-    target: any;
-    argument: any;
-    role: any;
-    identify: any;
-    extensionId: any;
-}): {
-    slot: {
-        kind: string;
-        value: string | number | boolean;
-    } | {
-        kind: string;
-        value?: never;
-    };
-    metadata: {
-        role: any;
-        source: any;
-        identity: string;
-        reason: any;
-    };
-    signatureParts: any[];
-} | {
-    slot: {
-        kind: string;
-        value?: never;
-    };
-    metadata: {
-        role: any;
-        source: string;
-        identity: string;
-        field?: never;
-    };
-    signatureParts: any[];
-} | {
-    signatureParts: any[];
-    binding?: {
-        restoreState?: {
-            colors: any[];
-            hsv: any[][];
-            blockProperties: any;
-        };
-        block: any;
-        field: any;
-        fieldName: any;
-        value: string;
-        vmBlock: any;
-        kind: string;
-        Class: any;
-        prototype: any;
-        allowedValues: readonly string[] | null | undefined;
-        restoreValue: any;
-        rawState: any;
-        restoreHandles: any;
-        restoreDom: any;
-    };
-    slot: {
-        kind: string;
-        value: string | number;
-    };
-    metadata: {
-        role: any;
-        source: string;
-        identity: string;
-        field: {
-            blockId: any;
-            name: any;
-            type: string | undefined;
-        };
-    };
-} | null;
+export declare function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, argument, role, identify, extensionId }: {
+    ScratchBlocks: NativeScratchBlocks;
+    block: NativeBlock;
+    vmBlock: VMBlock;
+    target: NativeTarget;
+    argument: string;
+    role: FixedInputMetadata['role'];
+    identify: Identify;
+    extensionId: string;
+}): Inspection | null;
 /** Validate the exact saved primitive; native setters must not silently normalize it. */
-export function prepareFixedChange(binding: any, value: any): any;
+export declare function prepareFixedChange(binding: FieldBinding, value: unknown): {
+    next: string;
+    block: NativeBlock;
+    field: NativeField;
+    fieldName: string;
+    value: string;
+    vmBlock: VMBlock;
+    kind: "text" | "number" | "menu" | "color";
+    Class: NativeFieldClass;
+    prototype: object;
+    allowedValues: readonly string[] | null | undefined;
+    restoreValue: NativeField["setValue"];
+    rawState: PropertyState[];
+    restoreHandles(): void;
+    restoreDom(): void;
+    restoreState?: ReturnType<typeof colorState>;
+};
 /** Capture a later external value without invoking replacement field methods. */
-export function captureFixedFieldState(binding: any): any;
+export declare function captureFixedFieldState(binding: FieldBinding): FieldBinding;
 /** Restore raw text and the standard color field's additional block/UI state. */
-export function restoreFixedField(binding: any): void;
+export declare function restoreFixedField(binding: FieldBinding): void;
+export {};

package/dist/turbowarp/fixed-fields.js

@@ -3,7 +3,7 @@ const own = (object, key) => {
     const descriptor = object && Object.getOwnPropertyDescriptor(object, key);
     return descriptor && 'value' in descriptor ? descriptor.value : undefined;
 };
-const primitive = value => typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+const primitive = (value) => typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
 const token = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
 // Inspect data properties without invoking custom field accessors or menu providers.
 const inherited = (object, name) => {
@@ -41,7 +41,7 @@ const safeField = (field, Class) => {
         if (currentPrototype !== entry.prototype)
             return false;
         for (const [name, expected] of entry.own) {
-            const actual = Object.getOwnPropertyDescriptor(currentPrototype, name);
+            const actual = Object.getOwnPropertyDescriptor(entry.prototype, name);
             if (Boolean(actual) !== Boolean(expected) ||
                 (actual && (!('value' in actual) || !expected || !('value' in expected) || actual.value !== expected.value)))
                 return false;
@@ -71,7 +71,7 @@ const safeField = (field, Class) => {
     }
     return false;
 };
-const arrayData = value => {
+const arrayData = (value) => {
     if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
         return null;
     const result = [];
@@ -83,7 +83,7 @@ const arrayData = value => {
     }
     return result;
 };
-const staticValues = field => {
+const staticValues = (field) => {
     const items = arrayData(own(field, 'menuGenerator_'));
     if (!items || items.length === 0)
         return null;
@@ -156,7 +156,7 @@ export function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, ar
         return { slot: { kind: 'reporter' }, metadata: { role, source: 'reporter', identity: JSON.stringify(sourceIdentity) },
             signatureParts: sourceIdentity };
     }
-    let owner = direct ? block : connected;
+    const owner = direct ? block : connected;
     if (!owner) {
         if (vmBlock.fields && owns(vmBlock.fields, argument))
             return null;
@@ -204,7 +204,7 @@ export function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, ar
             }
         if (names.length !== 1)
             return unavailable('unsupported', 'The menu shadow does not have one standard field.');
-        [name] = names;
+        name = names[0];
     }
     else
         return unavailable('unsupported', 'The shadow field family is unsupported.');

package/dist/turbowarp/fixed-transaction.d.ts

@@ -1,18 +1,23 @@
-export default function createFixedInputPort({ ScratchBlocks, workspace, vm, registry, identify, getState, begin, markEvent, finish, onError, subscribeScope }: {
-    ScratchBlocks: any;
-    workspace: any;
-    vm: any;
-    registry: any;
-    identify: any;
-    getState: any;
-    begin: any;
-    markEvent: any;
-    finish: any;
-    onError: any;
-    subscribeScope: any;
-}): Readonly<{
-    capability: "fixed-inputs-v1";
-    readBlock: (reference: any, declaration: any) => import("../fixed-input-types.js").FixedBlockSnapshot | null;
-    commit: (request: any) => void;
-    subscribeInvalidation: (reference: any, declaration: any, listener: any) => () => void;
-}>;
+import type { FixedInputEditorHost } from '../fixed-input-types.js';
+import type { EditorRegistry } from '../registry.js';
+import type { Identify, NativeChange, NativeScratchBlocks, NativeVM, NativeWorkspace } from './native-types.js';
+interface FixedPortOptions {
+    ScratchBlocks: NativeScratchBlocks;
+    workspace: NativeWorkspace;
+    vm: NativeVM;
+    registry: EditorRegistry;
+    identify: Identify;
+    getState(): {
+        disposed: boolean;
+        revision: number;
+        generation: number;
+        externalRevision: number;
+    };
+    begin(): void;
+    markEvent(event: NativeChange): void;
+    finish(succeeded: boolean): void;
+    onError(error: unknown): void;
+    subscribeScope(listener: () => void): () => void;
+}
+export default function createFixedInputPort({ ScratchBlocks, workspace, vm, registry, identify, getState, begin, markEvent, finish, onError, subscribeScope }: FixedPortOptions): FixedInputEditorHost;
+export {};

package/dist/turbowarp/fixed-transaction.js

@@ -4,7 +4,7 @@ import { initializeFixedFields, inspectFixedArgument, prepareFixedChange, restor
 import { snapshotJson } from '../schema-json.js';
 import { validateFixedBranchChanges } from '../fixed-input-branches.js';
 const own = (object, name) => {
-    const descriptor = object && Object.getOwnPropertyDescriptor(object, name);
+    const descriptor = object ? Object.getOwnPropertyDescriptor(object, name) : undefined;
     if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
         throw new TypeError('Expected an own data property.');
     }
@@ -21,9 +21,10 @@ const inheritedData = (object, key) => {
     }
     return undefined;
 };
-const ensureNativeHistory = stack => {
+const ensureNativeHistory = (stack) => {
+    var _a;
     if (!Array.isArray(stack) || !Object.isExtensible(stack) ||
-        Object.getOwnPropertySymbols(stack).length || !Object.getOwnPropertyDescriptor(stack, 'length').writable) {
+        Object.getOwnPropertySymbols(stack).length || !((_a = Object.getOwnPropertyDescriptor(stack, 'length')) === null || _a === void 0 ? void 0 : _a.writable)) {
         throw new TypeError('Unsupported undo history.');
     }
     if (Object.getOwnPropertyNames(stack).length !== stack.length + 1)
@@ -35,7 +36,7 @@ const ensureNativeHistory = stack => {
         }
     }
 };
-const copyHistory = stack => {
+const copyHistory = (stack) => {
     const copy = [];
     for (let index = 0; index < stack.length; index++)
         copy.push(own(stack, String(index)));
@@ -46,11 +47,11 @@ const replaceHistory = (stack, values) => {
     for (const value of values)
         Array.prototype.push.call(stack, value);
 };
-const conflict = () => { throw new BlockEditorConflictError(); };
+function conflict() { throw new BlockEditorConflictError(); }
 const aborted = Object.getOwnPropertyDescriptor(AbortSignal.prototype, 'aborted').get;
-const isAborted = signal => aborted.call(signal);
+const isAborted = (signal) => aborted.call(signal);
 const optionalOwn = (object, name) => {
-    const descriptor = object && Object.getOwnPropertyDescriptor(object, name);
+    const descriptor = object ? Object.getOwnPropertyDescriptor(object, name) : undefined;
     if (descriptor && !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
         throw new TypeError('VM state must contain data properties.');
     }
@@ -79,7 +80,7 @@ const untouchedState = (block, vmBlock, target, bindings, identify) => {
     }
     const seen = new Set();
     const records = [];
-    const capture = item => {
+    const capture = (item) => {
         if (!item || seen.has(item))
             return;
         seen.add(item);
@@ -112,8 +113,7 @@ const untouchedState = (block, vmBlock, target, bindings, identify) => {
     });
     return JSON.stringify([records, connections, statementConnections]);
 };
-const sameDeclaration = (left, right) => JSON.stringify(captureFixedInputDeclaration(left)) ===
-    JSON.stringify(captureFixedInputDeclaration(right));
+const sameDeclaration = (left, right) => JSON.stringify(captureFixedInputDeclaration(left)) === JSON.stringify(captureFixedInputDeclaration(right));
 // Fixed inputs deliberately use a separate transaction from the legacy TEXT adapter.
 export default function createFixedInputPort({ ScratchBlocks, workspace, vm, registry, identify, getState, begin, markEvent, finish, onError, subscribeScope }) {
     initializeFixedFields(ScratchBlocks);
@@ -162,7 +162,7 @@ export default function createFixedInputPort({ ScratchBlocks, workspace, vm, reg
             } }, reference, declaration);
         return { snapshot, bindings, declaration, target, block, vmBlock, state, untouched, runtime: vm.runtime };
     };
-    const commit = request => {
+    const commit = (request) => {
         var _a;
         const expectedInput = own(request, 'expected');
         const changesInput = own(request, 'changes');
@@ -238,7 +238,7 @@ export default function createFixedInputPort({ ScratchBlocks, workspace, vm, reg
         ensureNativeHistory(redoStack);
         const configuredMaxUndo = inheritedData(workspace, 'MAX_UNDO');
         const maxUndo = configuredMaxUndo === undefined ? Infinity : configuredMaxUndo;
-        if (maxUndo !== Infinity && (!Number.isSafeInteger(maxUndo) || maxUndo < 0)) {
+        if (typeof maxUndo !== 'number' || (maxUndo !== Infinity && (!Number.isSafeInteger(maxUndo) || maxUndo < 0))) {
             throw new TypeError('Unsupported undo configuration.');
         }
         const undo = copyHistory(undoStack);
@@ -290,7 +290,7 @@ export default function createFixedInputPort({ ScratchBlocks, workspace, vm, reg
                         const fields = edited.vmBlock.fields;
                         const field = fields && fields[edited.fieldName];
                         externalWrites.set(edited.field, { binding: captureFixedFieldState(edited),
-                            fields, field, descriptors: field && Object.getOwnPropertyDescriptors(field) });
+                            field, descriptors: field && Object.getOwnPropertyDescriptors(field) });
                     }
                     activeEvent = previous;
                 }

package/dist/turbowarp/host.d.ts

@@ -1,19 +1,3 @@
+import type { TurboWarpHostOptions, TurboWarpBlockEditorHost } from '../turbowarp.js';
+declare const createBlockEditorHost: ({ ScratchBlocks: nativeBlocks, workspace: nativeWorkspace, vm: nativeVM, registry, enableDescendants, enableFixedInputs, onError }: TurboWarpHostOptions) => TurboWarpBlockEditorHost;
 export default createBlockEditorHost;
-declare function createBlockEditorHost({ ScratchBlocks, workspace, vm, registry, enableDescendants, enableFixedInputs, onError }: {
-    ScratchBlocks: any;
-    workspace: any;
-    vm: any;
-    registry: any;
-    enableDescendants?: boolean | undefined;
-    enableFixedInputs?: boolean | undefined;
-    onError?: ((...data: any[]) => void) | undefined;
-}): {
-    isCommitting: () => boolean;
-    readBlock: (reference: any) => any;
-    commit: ({ expected, changes }: {
-        expected: any;
-        changes: any;
-    }) => void;
-    invalidate: () => void;
-    dispose: () => void;
-};

package/dist/turbowarp/host.js

@@ -3,7 +3,10 @@ import collectBlockEditorSubtree from './subtree.js';
 import createFixedInputPort from './fixed-transaction.js';
 const owns = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 // Adapt only standard, unvalidated text shadows; never evaluate connected reporters.
-const createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDescendants = false, enableFixedInputs = false, onError = console.error }) => {
+const createBlockEditorHost = ({ ScratchBlocks: nativeBlocks, workspace: nativeWorkspace, vm: nativeVM, registry, enableDescendants = false, enableFixedInputs = false, onError = console.error }) => {
+    const ScratchBlocks = nativeBlocks;
+    const workspace = nativeWorkspace;
+    const vm = nativeVM;
     let disposed = false;
     let committing = false;
     let revision = 0;
@@ -30,12 +33,12 @@ const createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableD
     };
     let notifyInvalidations = () => { };
     const identities = new WeakMap();
-    const identify = object => {
+    const identify = (object) => {
         if (!identities.has(object))
             identities.set(object, ++identity);
         return identities.get(object);
     };
-    const invalidate = event => {
+    const invalidate = (event) => {
         if (event && event.isUiEvent)
             return;
         revision++;
@@ -163,7 +166,7 @@ const createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableD
             vmBlock
         };
     };
-    const collect = reference => collectBlockEditorSubtree({ ScratchBlocks, reference, inspect, generation });
+    const collect = (reference) => collectBlockEditorSubtree({ ScratchBlocks, reference, inspect, generation });
     notifyInvalidations = () => {
         if (committing)
             return;
@@ -171,7 +174,7 @@ const createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableD
             let matches = false;
             try {
                 const current = collect(item.reference);
-                matches = current && JSON.stringify(current.snapshot) === JSON.stringify(item.snapshot);
+                matches = current !== null && JSON.stringify(current.snapshot) === JSON.stringify(item.snapshot);
             }
             catch (error) {
                 // A malformed replacement graph invalidates an already open session too.
@@ -201,7 +204,7 @@ const createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableD
         Events.disable();
         committing = true;
         try {
-            if (signal && signal.aborted)
+            if (!target || (signal && signal.aborted))
                 throw new BlockEditorConflictError();
             for (const item of prepared) {
                 item.field.setValue(item.next);

package/dist/turbowarp/icon.d.ts

@@ -1,9 +1,2 @@
+declare const bindBlockEditorIcon: ({ element, label, canOpen, onOpen, onHover, onLeave }: Parameters<typeof import("../turbowarp.js").bindBlockEditorIcon>[0]) => () => void;
 export default bindBlockEditorIcon;
-declare function bindBlockEditorIcon({ element, label, canOpen, onOpen, onHover, onLeave }: {
-    element: any;
-    label: any;
-    canOpen: any;
-    onOpen: any;
-    onHover?: (() => void) | undefined;
-    onLeave?: (() => void) | undefined;
-}): () => void;

package/dist/turbowarp/icon.js

@@ -4,13 +4,13 @@ const bindBlockEditorIcon = ({ element, label, canOpen, onOpen, onHover = () =>
     const previous = attributes.map(name => element.getAttribute(name));
     const oldCursor = element.style.cursor;
     let press = null;
-    const stop = event => {
+    const stop = (event) => {
         if (!canOpen())
             return;
         event.stopPropagation();
         event.preventDefault();
     };
-    const down = event => {
+    const down = (event) => {
         if (!canOpen() || event.button !== 0 || event.isPrimary === false)
             return;
         stop(event);
@@ -19,14 +19,14 @@ const bindBlockEditorIcon = ({ element, label, canOpen, onOpen, onHover = () =>
         if (element.setPointerCapture)
             element.setPointerCapture(event.pointerId);
     };
-    const move = event => {
+    const move = (event) => {
         if (!press || press.id !== event.pointerId)
             return;
         stop(event);
         if (Math.hypot(event.clientX - press.x, event.clientY - press.y) > 4)
             press.moved = true;
     };
-    const up = event => {
+    const up = (event) => {
         if (!press || press.id !== event.pointerId)
             return;
         move(event);
@@ -41,7 +41,7 @@ const bindBlockEditorIcon = ({ element, label, canOpen, onOpen, onHover = () =>
     const cancel = () => {
         press = null;
     };
-    const key = event => {
+    const key = (event) => {
         if ((event.key === 'Enter' || event.key === ' ') && canOpen()) {
             stop(event);
             if (!event.repeat)
@@ -68,7 +68,7 @@ const bindBlockEditorIcon = ({ element, label, canOpen, onOpen, onHover = () =>
         for (const [type, listener] of listeners)
             element.removeEventListener(type, listener);
         attributes.forEach((name, index) => {
-            if (previous[index] === null)
+            if (previous[index] == null)
                 element.removeAttribute(name);
             else
                 element.setAttribute(name, previous[index]);

package/dist/turbowarp/native-types.d.ts

@@ -0,0 +1,136 @@
+import type { BlockSnapshot } from '../types.js';
+export interface NativeField {
+    name?: string;
+    getValue(): unknown;
+    getText(): string;
+    setValue(value: string): void;
+    getValidator(): unknown;
+}
+interface ImageField extends NativeField {
+    fieldGroup_: SVGElement;
+    imageElement_: {
+        tooltip: unknown;
+    };
+    setTooltip(label: string): void;
+}
+export interface NativeFieldClass {
+    new (...args: never[]): NativeField;
+    prototype: NativeField;
+}
+interface Connection {
+    targetConnection: Connection | null;
+    targetBlock(): NativeBlock | null;
+}
+export interface NativeBlock {
+    id: string;
+    type: string;
+    isInFlyout?: boolean;
+    inputList: Array<{
+        name: string;
+        type: number;
+        fieldRow: NativeField[];
+        connection: Connection | null;
+    }>;
+    previousConnection: Connection | null;
+    nextConnection: Connection | null;
+    outputConnection: Connection | null;
+    isShadow(): boolean;
+    isEditable(): boolean;
+    getInput(name: string): NativeBlock['inputList'][number] | null;
+    getField(name: string): NativeField | null;
+    getParent(): NativeBlock | null;
+    getNextBlock(): NativeBlock | null;
+    getColour(): unknown;
+    getColourSecondary(): unknown;
+    getColourTertiary(): unknown;
+    getColourQuaternary(): unknown;
+    setColour(...colors: string[]): void;
+}
+export interface NativeChange {
+    type: string;
+    element?: string;
+    name?: string;
+    blockId?: string;
+    ids?: string[];
+    isUiEvent?: boolean;
+    oldValue?: unknown;
+    recordUndo: boolean;
+}
+export interface NativeScratchBlocks {
+    INPUT_VALUE: number;
+    NEXT_STATEMENT: number;
+    FieldImage: new (...args: never[]) => ImageField;
+    FieldTextInput: NativeFieldClass;
+    FieldNumber: NativeFieldClass;
+    FieldDropdown: NativeFieldClass;
+    FieldColourSlider: NativeFieldClass;
+    hideChaff(): void;
+    Events: {
+        Change: new (block: NativeBlock, element: string, name: string, before: string, after: string) => NativeChange;
+        recordUndo: boolean;
+        isEnabled(): boolean;
+        getGroup(): string | boolean;
+        setGroup(group: string | boolean): void;
+        disable(): void;
+        enable(): void;
+    };
+}
+export interface NativeWorkspace {
+    isFlyout?: boolean;
+    options: {
+        readOnly?: boolean;
+    };
+    isDragging?(): boolean;
+    getBlockById(id: string): NativeBlock | null;
+    getAllBlocks(ordered: boolean): NativeBlock[];
+    addChangeListener(listener: (event: NativeChange) => void): void;
+    removeChangeListener(listener: (event: NativeChange) => void): void;
+    undoStack_: NativeChange[];
+    redoStack_: NativeChange[];
+    fireChangeListener(event: NativeChange): void;
+}
+export interface VMField {
+    [name: string]: unknown;
+    id?: string;
+    value: unknown;
+}
+export interface VMBlock {
+    opcode: string;
+    parent?: string | null;
+    next?: string | null;
+    fields: Record<string, VMField>;
+    inputs: Record<string, {
+        block?: string;
+        shadow?: string;
+    }>;
+    mutation?: unknown;
+}
+export interface NativeTarget {
+    id: string;
+    blocks: {
+        getBlock(id: string): VMBlock | null;
+        blocklyListen(event: NativeChange): void;
+        resetCache?(): void;
+    };
+}
+export interface NativeVM {
+    editingTarget: NativeTarget | null;
+    runtime: {
+        emitProjectChanged(): void;
+    };
+    on(name: string, listener: () => void): void;
+    removeListener(name: string, listener: () => void): void;
+}
+export interface TextBinding {
+    shadow: NativeBlock;
+    field: NativeField;
+    value: string;
+}
+export interface BlockRecord {
+    block: NativeBlock;
+    vmBlock: VMBlock;
+    fields: Map<string, TextBinding>;
+    snapshot: BlockSnapshot;
+}
+export type Identify = (value: object) => number;
+export {};

package/dist/turbowarp/native-types.js

@@ -0,0 +1 @@
+export {};

package/dist/turbowarp/subtree.d.ts

@@ -1,10 +1,13 @@
-export default collectBlockEditorSubtree;
-declare function collectBlockEditorSubtree({ ScratchBlocks, reference, inspect, generation }: {
-    ScratchBlocks: any;
-    reference: any;
-    inspect: any;
-    generation: any;
-}): {
-    snapshot: any;
-    records: Map<any, any>;
+import type { SubtreeSnapshot } from '../descendant-types.js';
+import type { BlockReference } from '../types.js';
+import type { BlockRecord, NativeScratchBlocks } from './native-types.js';
+declare const collectBlockEditorSubtree: ({ ScratchBlocks, reference, inspect, generation }: {
+    ScratchBlocks: NativeScratchBlocks;
+    reference: BlockReference;
+    inspect(reference: BlockReference, structural: boolean): BlockRecord | null;
+    generation: number;
+}) => {
+    snapshot: SubtreeSnapshot;
+    records: Map<string, BlockRecord>;
 } | null;
+export default collectBlockEditorSubtree;

package/dist/turbowarp/subtree.js

@@ -4,9 +4,10 @@ const collectBlockEditorSubtree = ({ ScratchBlocks, reference, inspect, generati
     const nodes = [];
     const records = new Map();
     const pending = {};
-    const invalid = message => {
+    function invalid(message) {
         throw new BlockEditorStructureError(message, 'invalid-structure');
-    };
+    }
+    ;
     const visit = (id, depth) => {
         if (records.has(id)) {
             throw new BlockEditorStructureError('A statement block is connected more than once.', 'cycle');