@kubohiroya/turbowarp-plus-editor-project-model 0.1.1 → 0.2.0

package/dist/project-search.js

@@ -0,0 +1,282 @@
+// The judgement for broadcast blocks lives in project-messages, which the layout's message
+// section also uses, so the section and this search agree.
+import { messageReference } from "./project-messages.js";
+export const variableAccessLabels = {
+    read: ['読み取り', 'Read'],
+    write: ['変更', 'Write']
+};
+export const literalSearchPattern = (query, flags) => new RegExp(query.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+const headings = {
+    block: ['ブロック', 'Blocks'],
+    variable: ['変数の使用箇所', 'Variable uses'],
+    list: ['リストの使用箇所', 'List uses'],
+    message: ['メッセージの送受信', 'Broadcasts'],
+    argument: ['ブロックの引数値', 'Block argument values'],
+    extension: ['機能拡張の使用箇所', 'Extension uses'],
+    comment: ['コメント', 'Comments'],
+    costume: ['コスチューム', 'Costumes'],
+    backdrop: ['背景', 'Backdrops'],
+    sound: ['音', 'Sounds']
+};
+function* walkBlocks(target) {
+    const pending = target.blocks.getScripts().slice().reverse();
+    const seen = new Set();
+    while (pending.length) {
+        const id = pending.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const block = target.blocks.getBlock(id);
+        if (!block || block.shadow)
+            continue;
+        const inputs = [];
+        for (const [key, input] of Object.entries(block.inputs ?? {})) {
+            const child = input.block && target.blocks.getBlock(input.block);
+            if (child)
+                inputs.push([key, child]);
+        }
+        if (block.next)
+            pending.push(block.next);
+        for (let i = inputs.length - 1; i >= 0; i--) {
+            if (!inputs[i][1].shadow)
+                pending.push(inputs[i][1].id);
+        }
+        yield { block, inputs };
+    }
+}
+const stageProperties = new Set(['background #', 'backdrop #', 'backdrop name', 'volume']);
+const spriteProperties = new Set(['x position', 'y position', 'direction', 'costume #', 'costume name', 'size', 'volume']);
+const listAccesses = new Map([
+    ['data_listcontents', 'read'], ['data_itemoflist', 'read'], ['data_itemnumoflist', 'read'],
+    ['data_lengthoflist', 'read'], ['data_listcontainsitem', 'read'],
+    ['data_addtolist', 'write'], ['data_deleteoflist', 'write'], ['data_deletealloflist', 'write'],
+    ['data_insertatlist', 'write'], ['data_replaceitemoflist', 'write']
+]);
+function variableAccess(target, block, inputs, stage, sprites) {
+    if (block.opcode === 'sensing_of') {
+        const menu = inputs.find(([key]) => key === 'OBJECT')?.[1];
+        if (!menu?.shadow || menu.opcode !== 'sensing_of_object_menu')
+            return;
+        const object = menu.fields?.OBJECT?.value;
+        const name = block.fields?.PROPERTY?.value;
+        if (typeof object !== 'string' || typeof name !== 'string')
+            return;
+        const owner = object === '_stage_' ? stage : sprites.get(object);
+        if (!owner || (owner.isStage ? stageProperties : spriteProperties).has(name))
+            return;
+        const variableId = Object.keys(owner.variables).find(id => {
+            const variable = owner.variables[id];
+            return variable.type === '' && variable.name === name;
+        });
+        if (variableId)
+            return { owner, variableId, access: 'read' };
+        return;
+    }
+    const listAccess = listAccesses.get(block.opcode);
+    const access = listAccess ?? (block.opcode === 'data_variable' ? 'read' :
+        block.opcode === 'data_setvariableto' || block.opcode === 'data_changevariableby' ? 'write' : undefined);
+    const variableId = block.fields?.[listAccess ? 'LIST' : 'VARIABLE']?.id;
+    if (!access || !variableId)
+        return;
+    const owner = Object.hasOwn(target.variables, variableId) ? target : stage;
+    if (owner?.variables[variableId]?.type === (listAccess ? 'list' : ''))
+        return { owner, variableId, access };
+}
+const originalSprites = (project) => new Map(project.targets.filter(target => target.isOriginal && !target.isStage).map(target => [target.getName(), target]));
+export function countVariableAccesses(project, ownerId) {
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = originalSprites(project);
+    const counts = new Map();
+    for (const target of project.targets) {
+        if (!target.isOriginal)
+            continue;
+        for (const { block, inputs } of walkBlocks(target)) {
+            const use = variableAccess(target, block, inputs, stage, sprites);
+            if (use?.owner.id !== ownerId)
+                continue;
+            const count = counts.get(use.variableId) ?? { read: 0, write: 0 };
+            count[use.access]++;
+            counts.set(use.variableId, count);
+        }
+    }
+    return counts;
+}
+export function searchProject(project, messages, query, japanese, kinds = new Set(Object.keys(headings)), variableSearch) {
+    const groups = new Map(Object.entries(headings).map(([kind, titles]) => [
+        kind, { kind: kind, title: titles[japanese ? 0 : 1], results: [] }
+    ]));
+    const search = query.trim().toLocaleLowerCase();
+    if (!search && !variableSearch)
+        return [];
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = variableSearch || kinds.has('variable') ? originalSprites(project) : undefined;
+    const searchBlocks = variableSearch || ['block', 'variable', 'list', 'message', 'argument', 'extension']
+        .some(kind => kinds.has(kind));
+    const templates = new Map();
+    const matches = (value) => value.toLocaleLowerCase().includes(search);
+    const describeOpcode = (opcode) => {
+        const cached = templates.get(opcode);
+        if (cached)
+            return cached;
+        const key = opcode.toUpperCase();
+        const alternate = key.replace(/^OPERATOR_/, 'OPERATORS_').replace(/_AS_CLONE$/, 'ASCLONE');
+        const vmLabel = project.getLabelForOpcode?.(opcode);
+        const vmText = vmLabel?.label;
+        const separator = vmLabel?.category === 'extension' ? vmText?.indexOf(': ') ?? -1 : -1;
+        const template = {
+            text: messages[key] ?? messages[alternate] ??
+                (vmText && separator > 0 ? vmText.slice(separator + 2) : vmText) ?? opcode.replaceAll('_', ' '),
+            extension: vmText && separator > 0 ? vmText.slice(0, separator) : undefined
+        };
+        templates.set(opcode, template);
+        return template;
+    };
+    const fieldText = (target, key, field) => {
+        const variable = field.id && (key === 'VARIABLE' || key === 'LIST') ?
+            target.variables[field.id] ?? stage?.variables[field.id] : undefined;
+        return String(variable?.name ?? field.value ?? '');
+    };
+    const describe = (target, block, inputs, template) => {
+        const values = [
+            ...Object.entries(block.fields ?? {}).map(([key, field]) => fieldText(target, key, field)),
+            ...inputs.filter(([key]) => !key.startsWith('SUBSTACK')).map(([, child]) => child.shadow ? Object.values(child.fields ?? {}).map(field => String(field.value ?? '')).join(' ') :
+                Object.entries(child.fields ?? {}).map(([key, field]) => fieldText(target, key, field)).join(' ') || '…')
+        ];
+        if (block.opcode === 'event_whenflagclicked')
+            values.unshift(japanese ? '緑の旗' : 'green flag');
+        if (/%\d+/.test(template))
+            return template.replace(/%(\d+)/g, (_, index) => values[Number(index) - 1] ?? '…').trim();
+        return [template, ...values].filter(Boolean).join(' ');
+    };
+    for (const target of project.targets) {
+        if (!target.isOriginal)
+            continue;
+        for (const { block, inputs } of searchBlocks ? walkBlocks(target) : []) {
+            const use = sprites && variableAccess(target, block, inputs, stage, sprites);
+            if (variableSearch && (!use || use.owner.id !== variableSearch.ownerId ||
+                use.variableId !== variableSearch.variableId || use.access !== variableSearch.access))
+                continue;
+            const variable = block.fields?.VARIABLE;
+            const list = block.fields?.LIST;
+            const message = messageReference(target, block, stage);
+            const kind = variable ? 'variable' : list ? 'list' : 'message';
+            const reference = variable ?? list ?? (message && { id: message.id, value: message.fieldValue });
+            const name = variable || list ? fieldText(target, variable ? 'VARIABLE' : 'LIST', reference) : message?.name;
+            const opcode = describeOpcode(block.opcode);
+            const procedure = block.mutation?.proccode ??
+                inputs.find(([key]) => key === 'custom_block')?.[1].mutation?.proccode;
+            const customLabel = block.mutation?.blockInfo?.text;
+            const template = procedure ? procedure.replace(/%[sbn]/g, '…') :
+                typeof customLabel === 'string' ? customLabel : opcode.text;
+            const label = procedure ? template : describe(target, block, inputs, template);
+            const add = (kind, label, detail, edit, access) => groups.get(kind).results.push({ kind, target, block, label, detail, edit, variableAccess: access });
+            if (variableSearch && use) {
+                add(list ? 'list' : 'variable', label, use.owner.variables[use.variableId].name, undefined, use.access);
+                continue;
+            }
+            if (kinds.has('block') && (matches(template) || matches(block.opcode) ||
+                (block.opcode === 'event_whenflagclicked' && matches(japanese ? '緑の旗' : 'green flag')))) {
+                add('block', label, undefined, procedure ? { type: 'procedure', name: procedure } : undefined);
+            }
+            if (kinds.has(kind) && name && matches(name)) {
+                const referenceId = reference?.id;
+                const owner = referenceId &&
+                    (target.variables[referenceId] ? target : stage?.variables[referenceId] ? stage : undefined);
+                const scope = (variable || list) && owner &&
+                    (owner.isStage ? (japanese ? '全体' : 'Global') : (japanese ? 'このスプライト' : 'Local'));
+                const model = owner && referenceId ? owner.variables[referenceId] : undefined;
+                const edit = owner && referenceId && model && !model.isCloud ? {
+                    type: 'name', id: referenceId, owner, name: model.name,
+                    variableType: model.type ?? (list ? 'list' : message ? 'broadcast_msg' : '')
+                } : undefined;
+                add(kind, name, scope || label, edit, use?.access);
+            }
+            else if (use && !variable && !list && kinds.has('variable') && matches(use.owner.variables[use.variableId].name)) {
+                add('variable', use.owner.variables[use.variableId].name, label, undefined, use.access);
+            }
+            if (kinds.has('extension') && opcode.extension && matches(opcode.extension))
+                add('extension', opcode.extension, label);
+            if (kinds.has('argument')) {
+                const addArguments = (owner) => {
+                    for (const [key, field] of Object.entries(owner.fields ?? {})) {
+                        if (field === reference || (message && key === 'BROADCAST_OPTION'))
+                            continue;
+                        const value = String(field.value ?? '');
+                        if (value && matches(value))
+                            add('argument', value, label, { type: 'field', id: owner.id, field: key, value });
+                    }
+                };
+                addArguments(block);
+                for (const [, child] of inputs) {
+                    if (child.shadow)
+                        addArguments(child);
+                }
+            }
+        }
+        if (variableSearch)
+            continue;
+        if (kinds.has('comment')) {
+            for (const [commentId, comment] of Object.entries(target.comments ?? {})) {
+                if (matches(comment.text))
+                    groups.get('comment').results.push({
+                        kind: 'comment', target, comment, commentId, label: comment.text, edit: { type: 'comment', text: comment.text }
+                    });
+            }
+        }
+        const assets = [
+            [target.isStage ? 'backdrop' : 'costume', target.getCostumes()],
+            ['sound', target.getSounds()]
+        ];
+        for (const [kind, items] of assets) {
+            if (!kinds.has(kind))
+                continue;
+            for (const asset of items) {
+                if (matches(asset.name))
+                    groups.get(kind).results.push({ kind, asset, label: asset.name, target });
+            }
+        }
+    }
+    return [...groups.values()].filter(group => group.results.length);
+}
+export function searchYamlDocuments(documents, query, japanese) {
+    const results = [];
+    const search = query.trim();
+    if (!search)
+        return results;
+    const pattern = literalSearchPattern(search, 'giu');
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const { filename } of documents) {
+        if (seen.has(filename))
+            duplicates.add(filename);
+        seen.add(filename);
+    }
+    for (const document of documents) {
+        let line = 1;
+        let lineStart = 0;
+        let newline = document.source.indexOf('\n');
+        for (const match of document.source.matchAll(pattern)) {
+            const start = match.index;
+            const end = start + match[0].length;
+            while (newline >= 0 && newline < start) {
+                line++;
+                lineStart = newline + 1;
+                newline = document.source.indexOf('\n', lineStart);
+            }
+            const column = start - lineStart + 1;
+            const nextNewline = document.source.indexOf('\n', end);
+            const before = Math.max(lineStart, start - 48);
+            const lineEnd = nextNewline < 0 ? document.source.length : nextNewline;
+            const after = Math.min(lineEnd, end + 48);
+            const position = japanese ? `${line} 行 ${column} 列` : `Line ${line}, column ${column}`;
+            const identity = duplicates.has(document.filename) ?
+                `${document.reference.providerId}/${document.reference.documentId}` : '';
+            results.push({
+                kind: 'yaml', document, label: `${before > lineStart ? '…' : ''}${document.source.slice(before, after)}${after < lineEnd ? '…' : ''}`,
+                detail: [position, identity].filter(Boolean).join(' · '),
+                range: { start, end, expectedText: match[0] }
+            });
+        }
+    }
+    return results;
+}

package/dist/sprite-variable-edit.d.ts

@@ -1,6 +1,14 @@
+type VariableType = '' | 'list';
 export type SpriteVariableEdit = {
     type: 'create';
     name: string;
+    variableType?: '';
+    isCloud?: boolean;
+} | {
+    type: 'create';
+    name: string;
+    variableType: 'list';
+    isCloud?: false;
 } | {
     type: 'rename';
     id: string;
@@ -9,7 +17,7 @@ export type SpriteVariableEdit = {
     type: 'delete';
     id: string;
 };
-export type SpriteVariableEditError = 'emptyName' | 'duplicateName' | 'inUse' | 'unavailable';
+export type SpriteVariableEditError = 'emptyName' | 'duplicateName' | 'inUse' | 'unavailable' | 'cloudLimit';
 type Variable = {
     name: string;
     type: string;
@@ -29,9 +37,9 @@ type VariableEvent = {
     type: 'var_create';
     varId: string;
     varName: string;
-    varType: '';
+    varType: VariableType;
     isLocal: boolean;
-    isCloud: false;
+    isCloud: boolean;
 } | {
     type: 'var_rename';
     varId: string;
@@ -58,9 +66,78 @@ type VariableProject = {
         targets: readonly VariableTarget[];
         getEditingTarget(): VariableTarget | null;
         getTargetForStage(): VariableTarget | null;
+        canAddCloudVariable?(): boolean;
     };
     refreshWorkspace(): void;
 };
+export type SpriteListItem = string | number | boolean;
+export type SpriteVariableValue = string | number | readonly SpriteListItem[];
+type VariableValue = {
+    id: string;
+    name: string;
+    type: string;
+    value: unknown;
+    isCloud?: boolean;
+    _monitorUpToDate?: boolean;
+};
+export declare function readSpriteVariable(variable: VariableValue): {
+    id: string;
+    name: string;
+    value: readonly SpriteListItem[];
+    isCloud?: undefined;
+} | {
+    id: string;
+    name: string;
+    value: string | number;
+    isCloud: boolean | undefined;
+} | undefined;
+export declare function writeSpriteVariableValue(vm: {
+    runtime: {
+        getTargetById(id: string): {
+            variables: Record<string, VariableValue>;
+        } | undefined;
+    };
+    setVariableValue(targetId: string, variableId: string, value: SpriteVariableValue): boolean;
+}, targetId: string, id: string, value: SpriteVariableValue): boolean;
 export declare const cloudVariablePrefix = "\u2601 ";
+type VariableMonitorBlock = {
+    id: string;
+    opcode: string;
+    isMonitored?: boolean;
+    targetId: string | null;
+};
+type VariableMonitorRuntime = {
+    getTargetById(id: string): VariableTarget | undefined;
+    getMonitorState(): {
+        get(id: string): {
+            visible: boolean;
+        } | undefined;
+    };
+    monitorBlocks: {
+        getBlock(id: string): VariableMonitorBlock | undefined;
+        createBlock(block: VariableMonitorBlock & {
+            fields: Record<string, {
+                id: string;
+                name: string;
+                value: string;
+                variableType: '' | 'list';
+            }>;
+            inputs: Record<string, never>;
+            next: null;
+            parent: null;
+            topLevel: true;
+            shadow: false;
+            x: number;
+            y: number;
+        }): void;
+        changeBlock(change: {
+            id: string;
+            element: 'checkbox';
+            value: boolean;
+        }): void;
+    };
+    emitProjectChanged(): void;
+};
+export declare function showSpriteVariableOnStage(runtime: VariableMonitorRuntime, targetId: string, id: string, visible: boolean): void;
 export declare function editSpriteVariable(vm: VariableProject, targetId: string, edit: SpriteVariableEdit): SpriteVariableEditError | void;
 export {};

package/dist/sprite-variable-edit.js

@@ -1,4 +1,46 @@
+export function readSpriteVariable(variable) {
+    const { id, name, type, value, isCloud } = variable;
+    if (type === 'list' && Array.isArray(value))
+        return { id, name, value: value };
+    if (type === '' && (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean')) {
+        return { id, name, value: typeof value === 'boolean' ? String(value) : value, isCloud };
+    }
+}
+export function writeSpriteVariableValue(vm, targetId, id, value) {
+    const variable = vm.runtime.getTargetById(targetId)?.variables[id];
+    const list = typeof value === 'object';
+    if (!variable || variable.type !== (list ? 'list' : '') || !vm.setVariableValue(targetId, id, value))
+        return false;
+    if (list)
+        variable._monitorUpToDate = false;
+    return true;
+}
 export const cloudVariablePrefix = '☁ ';
+export function showSpriteVariableOnStage(runtime, targetId, id, visible) {
+    const owner = runtime.getTargetById(targetId);
+    const variable = owner?.variables[id];
+    if (!owner?.isOriginal || !variable || !['', 'list'].includes(variable.type) ||
+        Boolean(runtime.getMonitorState().get(id)?.visible) === visible)
+        return;
+    const list = variable.type === 'list';
+    const opcode = list ? 'data_listcontents' : 'data_variable';
+    const field = list ? 'LIST' : 'VARIABLE';
+    const { monitorBlocks } = runtime;
+    let block = monitorBlocks.getBlock(id);
+    if (!block) {
+        monitorBlocks.createBlock({
+            id, opcode, targetId: owner.isStage ? null : owner.id, inputs: {},
+            fields: { [field]: { id, name: field, value: variable.name, variableType: list ? 'list' : '' } },
+            next: null, parent: null, topLevel: true, shadow: false, x: 0, y: 0
+        });
+        block = monitorBlocks.getBlock(id);
+    }
+    if (block?.opcode !== opcode)
+        return;
+    block.isMonitored = !visible;
+    monitorBlocks.changeBlock({ id, element: 'checkbox', value: visible });
+    runtime.emitProjectChanged();
+}
 function isUsed(target, targets, id, name) {
     const targetName = target.isStage ? '_stage_' : target.getName();
     return targets.some(({ blocks }) => {
@@ -30,20 +72,29 @@ export function editSpriteVariable(vm, targetId, edit) {
         target.blocks.blocklyListen({ type: 'var_delete', varId: edit.id });
     }
     else {
-        const name = edit.name.trim();
+        const variableType = edit.type === 'create' ? edit.variableType ?? '' : '';
+        const cloud = edit.type === 'create' ? variableType === '' && edit.isCloud === true : variable?.isCloud === true;
+        const name = (cloud && edit.name.startsWith(cloudVariablePrefix) ?
+            edit.name.slice(cloudVariablePrefix.length) : edit.name).trim();
         if (!name)
             return 'emptyName';
-        const fullName = variable?.isCloud && !name.startsWith(cloudVariablePrefix) ? cloudVariablePrefix + name : name;
+        const fullName = cloud ? cloudVariablePrefix + name : name;
         if (fullName === variable?.name)
             return;
         const scope = target.isStage ? runtime.targets.filter(item => item.isStage || item.isOriginal) :
             [target, runtime.getTargetForStage()];
-        if (scope.some(owner => owner && Object.values(owner.variables).some(item => item.type === '' && item.name === fullName))) {
+        if (scope.some(owner => owner && Object.values(owner.variables).some(item => item.type === variableType && item.name === fullName))) {
             return 'duplicateName';
         }
         if (edit.type === 'create') {
+            if (cloud && !target.isStage)
+                return 'unavailable';
+            if (cloud && !runtime.canAddCloudVariable?.())
+                return 'cloudLimit';
             const varId = Array.from(crypto.getRandomValues(new Uint32Array(4)), value => value.toString(16).padStart(8, '0')).join('');
-            target.blocks.blocklyListen({ type: 'var_create', varId, varName: fullName, varType: '', isLocal: !target.isStage, isCloud: false });
+            target.blocks.blocklyListen({
+                type: 'var_create', varId, varName: fullName, varType: variableType, isLocal: !target.isStage, isCloud: cloud
+            });
         }
         else {
             target.blocks.blocklyListen({ type: 'var_rename', varId: edit.id, newName: fullName });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-plus-editor-project-model",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "UI-free reads and edits of a running Scratch project for TurboWarp Plus Editor",
   "type": "module",
   "license": "MPL-2.0",
@@ -21,6 +21,18 @@
     "./sprite-variable-edit": {
       "types": "./dist/sprite-variable-edit.d.ts",
       "default": "./dist/sprite-variable-edit.js"
+    },
+    "./project-search": {
+      "types": "./dist/project-search.d.ts",
+      "default": "./dist/project-search.js"
+    },
+    "./project-search-replace": {
+      "types": "./dist/project-search-replace.d.ts",
+      "default": "./dist/project-search-replace.js"
+    },
+    "./project-search-connections": {
+      "types": "./dist/project-search-connections.d.ts",
+      "default": "./dist/project-search-connections.js"
     }
   },
   "files": [

package/src/index.ts

@@ -1,2 +1,5 @@
 export * from './project-messages.ts';
 export * from './sprite-variable-edit.ts';
+export * from './project-search.ts';
+export * from './project-search-replace.ts';
+export * from './project-search-connections.ts';

package/src/project-search-connections.ts

@@ -0,0 +1,127 @@
+import type {ProjectSearchResult, SearchProject, VariableSearch, YamlSearchDocument, YamlSearchResult} from './project-search.ts';
+import type {ReplaceBlockly, ReplaceWorkspace} from './project-search-replace.ts';
+
+export type SearchDocuments = {
+    getSearchableYamlDocuments(): readonly YamlSearchDocument[];
+    openYamlPreview(reference: YamlSearchDocument['reference'], range: YamlSearchResult['range']): boolean;
+    stageYamlReplacement?(reference: YamlSearchDocument['reference'], range: YamlSearchResult['range'],
+        source: string, text: string): boolean;
+};
+
+type SearchView = {id: string; groupId: string; targetId: string; section: number};
+type SearchViews = {
+    views(): SearchView[];
+    currentView(): SearchView | undefined;
+    activateView(id: string): boolean;
+    select(id: string): void;
+    setViewSection(id: string, section: number): boolean;
+    selectAsset(id: string, kind: 'costumes' | 'sounds', index: number): void;
+};
+type Target = ProjectSearchResult['target'];
+export type SearchNavigation = {
+    getViews(): SearchViews | null;
+    getTarget(id: string): Target | undefined;
+    getEditingTarget(): Target | undefined;
+    centerBlock(id: string): void;
+    centerComment(id: string, blockId?: string | null): void;
+    replacementContext?(): {workspace: ReplaceWorkspace; Blockly: ReplaceBlockly} | undefined;
+};
+
+type SearchConnection = {
+    navigation?: SearchNavigation;
+    documents?: SearchDocuments;
+    openReplace?: () => void;
+    openVariable?: (filter: VariableSearch) => void;
+    listeners: Set<() => void>;
+};
+
+const connections = new WeakMap<SearchProject, SearchConnection>();
+
+export function connectionFor(project: SearchProject) {
+    let connection = connections.get(project);
+    if (!connection) {
+        connection = {listeners: new Set()};
+        connections.set(project, connection);
+    }
+    return connection;
+}
+
+/** Open a target's view in the active group and switch it to a section. */
+export function activateTargetView(navigation: SearchNavigation, targetId: string, section: number) {
+    const views = navigation.getViews();
+    if (!views) return undefined;
+    const groupId = views.currentView()?.groupId;
+    const local = views.views().find(view => view.groupId === groupId && view.targetId === targetId);
+    if (local) views.activateView(local.id);
+    else views.select(targetId);
+    const destination = views.currentView();
+    if (destination?.targetId !== targetId) return undefined;
+    views.setViewSection(destination.id, section);
+    return {views, viewId: destination.id, section};
+}
+
+export function connectProjectSearchNavigation(project: SearchProject, navigation: SearchNavigation) {
+    const connection = connectionFor(project);
+    connection.navigation = navigation;
+    connection.listeners.forEach(listener => listener());
+    return () => {
+        if (connection.navigation !== navigation) return;
+        connection.navigation = undefined;
+        connection.listeners.forEach(listener => listener());
+    };
+}
+
+export function connectProjectSearchDocuments(project: SearchProject, documents: SearchDocuments) {
+    const connection = connectionFor(project);
+    connection.documents = documents;
+    connection.listeners.forEach(listener => listener());
+    return () => {
+        if (connection.documents !== documents) return;
+        connection.documents = undefined;
+        connection.listeners.forEach(listener => listener());
+    };
+}
+
+export function connectProjectReplaceOpener(project: SearchProject, open: () => void) {
+    const connection = connectionFor(project);
+    connection.openReplace = open;
+    return () => {
+        if (connection.openReplace === open) connection.openReplace = undefined;
+    };
+}
+
+export function projectReplaceOpener(project?: SearchProject) {
+    return project && connections.get(project)?.openReplace;
+}
+
+export function connectVariableSearchOpener(project: SearchProject, open: (filter: VariableSearch) => void) {
+    const connection = connectionFor(project);
+    connection.openVariable = open;
+    return () => {
+        if (connection.openVariable === open) connection.openVariable = undefined;
+    };
+}
+
+export function openVariableSearch(project: SearchProject, filter: VariableSearch) {
+    connections.get(project)?.openVariable?.(filter);
+}
+
+const replaceKey = 'F';
+
+export function isMacPlatform() {
+    return typeof navigator !== 'undefined' && /^(Mac|iP)/.test(navigator.platform ?? '');
+}
+
+// Search is the platform's own find shortcut, so replace is the shifted form of it: ⇧⌘F on macOS
+// and Ctrl+Shift+F elsewhere.
+export const projectReplaceShortcut = {
+    keys: `Control+Shift+${replaceKey}`,
+    macKeys: `Meta+Shift+${replaceKey}`,
+    label: `Ctrl+Shift+${replaceKey}`,
+    macLabel: `⇧⌘${replaceKey}`,
+    matches(event: KeyboardEvent) {
+        const primary = isMacPlatform() ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+        return primary && event.shiftKey && !event.altKey && !event.isComposing &&
+            event.key.toUpperCase() === replaceKey;
+    }
+};