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

package/README.ja.md

@@ -10,7 +10,10 @@ TurboWarp Plus Editor で、実行中の Scratch 作品を画面なしで読み
 | --- | --- |
 | `@kubohiroya/turbowarp-plus-editor-project-model/project-messages` | どのブロックが各メッセージを送り、受け取るか（`scanProjectMessages`・`scanTargetMessages`・`projectMessageGraph`・`messageReference`）と、メッセージの名前を変えられるか（`checkMessageRename`） |
 | `@kubohiroya/turbowarp-plus-editor-project-model/sprite-variable-edit` | 編集中のスプライトまたはステージの変数の作成・名前変更・削除（`editSpriteVariable`）。重複する名前を拒み、クラウド変数の接頭辞を保ち、ブロックが使っている変数は削除しない |
-| `@kubohiroya/turbowarp-plus-editor-project-model` | 上の両方 |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search` | 作品全体の検索（`searchProject`・`searchYamlDocuments`・`countVariableAccesses`）。ブロック・変数・リスト・メッセージ・コメント・コスチューム・音を探し、変数ごとに読み書きの箇所を数える |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search-replace` | 検索結果の置換（`applyProjectSearchReplacement`・`renameProjectMessage`・`replacementText`）。Blockly とワークスペースは構造的な型で受け取り、古くなった結果・不正な名前・重複を拒む |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search-connections` | 検索と Editor のつなぎ（作品ごとの移動先・YAML 文書・置換を開く口、置換のショートカット） |
+| `@kubohiroya/turbowarp-plus-editor-project-model` | 上のすべて |
 
 ## 検証
 
@@ -18,4 +21,6 @@ TurboWarp Plus Editor で、実行中の Scratch 作品を画面なしで読み
 
 ## ライセンス
 
-MPL-2.0。`@kubohiroya/turbowarp-plus-editor-layout` から切り出したコードで、その履歴をこのリポジトリに残している。
+MPL-2.0。`project-messages`・`sprite-variable-edit` は `@kubohiroya/turbowarp-plus-editor-layout` から切り出したコードで、その履歴をこのリポジトリに残している。
+
+`project-search`・`project-search-replace`・`project-search-connections` は、turbowarp-plus-editor の `packages/editor-ui` から移した。同じ作者が書いたもので、GPL-3.0 から MPL-2.0 にした。由来の監査は [turbowarp-plus-packages の移行計画](https://github.com/kubohiroya/turbowarp-plus-packages/blob/main/docs/editor-migration-plan.ja.md)の「由来の監査（7b）」にある。

package/README.md

@@ -10,7 +10,10 @@ Reads and edits a running Scratch project for TurboWarp Plus Editor, without any
 | --- | --- |
 | `@kubohiroya/turbowarp-plus-editor-project-model/project-messages` | Which blocks send or receive each broadcast message (`scanProjectMessages`, `scanTargetMessages`, `projectMessageGraph`, `messageReference`), and whether a message can be renamed (`checkMessageRename`) |
 | `@kubohiroya/turbowarp-plus-editor-project-model/sprite-variable-edit` | Creating, renaming and deleting a variable of the editing sprite or the stage (`editSpriteVariable`). It refuses duplicate names, keeps the cloud prefix, and refuses to delete a variable that a block uses |
-| `@kubohiroya/turbowarp-plus-editor-project-model` | Both of the above |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search` | Search across the whole project (`searchProject`, `searchYamlDocuments`, `countVariableAccesses`): blocks, variables, lists, messages, comments, costumes and sounds, with the places each variable is read and written |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search-replace` | Replace a search result (`applyProjectSearchReplacement`, `renameProjectMessage`, `replacementText`). Blockly and the workspace come in as structural types; stale results, invalid names and duplicates are refused |
+| `@kubohiroya/turbowarp-plus-editor-project-model/project-search-connections` | What joins the search to the Editor: per-project hooks for navigation, YAML documents and opening replace, and the replace shortcut |
+| `@kubohiroya/turbowarp-plus-editor-project-model` | All of the above |
 
 ## Verification
 
@@ -18,4 +21,6 @@ Run `npm test` to build the package and run the unit tests.
 
 ## License
 
-MPL-2.0. This code was split out of `@kubohiroya/turbowarp-plus-editor-layout`, and its history is kept in this repository.
+MPL-2.0. `project-messages` and `sprite-variable-edit` were split out of `@kubohiroya/turbowarp-plus-editor-layout`, and their history is kept in this repository.
+
+`project-search`, `project-search-replace` and `project-search-connections` moved here from `packages/editor-ui` in turbowarp-plus-editor. The same author wrote them, and they changed from GPL-3.0 to MPL-2.0 in the move. The provenance audit is in the "由来の監査（7b）" section of the [migration plan in turbowarp-plus-packages](https://github.com/kubohiroya/turbowarp-plus-packages/blob/main/docs/editor-migration-plan.ja.md).

package/dist/index.d.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/dist/index.js

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

package/dist/project-search-connections.d.ts

@@ -0,0 +1,62 @@
+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>;
+};
+export declare function connectionFor(project: SearchProject): SearchConnection;
+/** Open a target's view in the active group and switch it to a section. */
+export declare function activateTargetView(navigation: SearchNavigation, targetId: string, section: number): {
+    views: SearchViews;
+    viewId: string;
+    section: number;
+} | undefined;
+export declare function connectProjectSearchNavigation(project: SearchProject, navigation: SearchNavigation): () => void;
+export declare function connectProjectSearchDocuments(project: SearchProject, documents: SearchDocuments): () => void;
+export declare function connectProjectReplaceOpener(project: SearchProject, open: () => void): () => void;
+export declare function projectReplaceOpener(project?: SearchProject): (() => void) | undefined;
+export declare function connectVariableSearchOpener(project: SearchProject, open: (filter: VariableSearch) => void): () => void;
+export declare function openVariableSearch(project: SearchProject, filter: VariableSearch): void;
+export declare function isMacPlatform(): boolean;
+export declare const projectReplaceShortcut: {
+    keys: string;
+    macKeys: string;
+    label: string;
+    macLabel: string;
+    matches(event: KeyboardEvent): boolean;
+};
+export {};

package/dist/project-search-connections.js

@@ -0,0 +1,87 @@
+const connections = new WeakMap();
+export function connectionFor(project) {
+    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, targetId, section) {
+    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, navigation) {
+    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, documents) {
+    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, open) {
+    const connection = connectionFor(project);
+    connection.openReplace = open;
+    return () => {
+        if (connection.openReplace === open)
+            connection.openReplace = undefined;
+    };
+}
+export function projectReplaceOpener(project) {
+    return project && connections.get(project)?.openReplace;
+}
+export function connectVariableSearchOpener(project, open) {
+    const connection = connectionFor(project);
+    connection.openVariable = open;
+    return () => {
+        if (connection.openVariable === open)
+            connection.openVariable = undefined;
+    };
+}
+export function openVariableSearch(project, filter) {
+    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) {
+        const primary = isMacPlatform() ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+        return primary && event.shiftKey && !event.altKey && !event.isComposing &&
+            event.key.toUpperCase() === replaceKey;
+    }
+};

package/dist/project-search-replace.d.ts

@@ -0,0 +1,50 @@
+import { type ProjectSearchResult, type SearchProject, type SearchResult } from './project-search.ts';
+type Field = {
+    getValue(): unknown;
+    setValue(value: string): void;
+    callValidator(value: string): unknown;
+    getOptions?(): ReadonlyArray<readonly [unknown, unknown]>;
+};
+type Comment = {
+    getText(): string;
+    setText(value: string): void;
+};
+type Block = {
+    isEditable(): boolean;
+    getField(name: string): Field | undefined;
+    comment?: Comment;
+    mutationToDom(): Element;
+};
+type RenameEvent = {
+    type: string;
+    varId?: string;
+    newName?: string;
+};
+export type ReplaceWorkspace = {
+    options: {
+        readOnly: boolean;
+    };
+    isDragging(): boolean;
+    getBlockById(id: string): Block | null;
+    getCommentById(id: string): Comment | null;
+    getVariableById(id: string): {
+        name: string;
+    } | null;
+    renameVariableById(id: string, name: string): void;
+    addChangeListener(listener: (event: RenameEvent) => void): void;
+};
+export type ReplaceBlockly = {
+    FieldTextInput: abstract new (...args: never[]) => Field;
+    FieldDropdown: abstract new (...args: never[]) => Field;
+    FieldNumber: abstract new (...args: never[]) => Field;
+    Procedures: {
+        getPrototypeBlock(name: string, workspace: ReplaceWorkspace): Block | null;
+        mutateCallersAndPrototype(name: string, workspace: ReplaceWorkspace, mutation: Element): void;
+    };
+};
+export type ReplaceOutcome = 'applied' | 'staged' | 'stale' | 'conflict' | 'invalid' | 'read-only';
+export declare function replacementText(result: SearchResult, query: string, replacement: string): string | undefined;
+/** Rename a message from the message section, where no block result carries the edit. */
+export declare function renameProjectMessage(project: SearchProject, workspace: ReplaceWorkspace, id: string, next: string): ReplaceOutcome;
+export declare function applyProjectSearchReplacement(project: SearchProject, workspace: ReplaceWorkspace, Blockly: ReplaceBlockly, result: ProjectSearchResult, next: string): ReplaceOutcome;
+export {};

package/dist/project-search-replace.js

@@ -0,0 +1,183 @@
+import { literalSearchPattern } from "./project-search.js";
+function spliceMatch(value, pattern, replacement) {
+    const match = pattern.exec(value);
+    if (match)
+        return value.slice(0, match.index) + replacement + value.slice(match.index + match[0].length);
+}
+function replaceProcedureLabel(name, pattern, replacement) {
+    if (/%[sbn]/.test(replacement))
+        return;
+    const parts = name.split(/(%[sbn])/);
+    for (let i = 0; i < parts.length; i += 2) {
+        const changed = spliceMatch(parts[i], pattern, replacement);
+        if (changed === undefined)
+            continue;
+        parts[i] = changed;
+        const next = parts.join('');
+        if (JSON.stringify(next.match(/%[sbn]/g)) === JSON.stringify(name.match(/%[sbn]/g)))
+            return next;
+        return;
+    }
+}
+export function replacementText(result, query, replacement) {
+    if (!query.trim())
+        return;
+    if (result.kind === 'yaml')
+        return replacement !== result.range.expectedText ? replacement : undefined;
+    const edit = result.edit;
+    if (!edit)
+        return;
+    const pattern = literalSearchPattern(query, 'iu');
+    const source = edit.type === 'name' || edit.type === 'procedure' ? edit.name : edit.type === 'comment' ? edit.text : edit.value;
+    const next = edit.type === 'procedure' ? replaceProcedureLabel(source, pattern, replacement) :
+        spliceMatch(source, pattern, replacement);
+    return next !== source ? next : undefined;
+}
+const watchedBroadcasts = new WeakMap();
+function maintainBroadcastReferences(project, workspace, id) {
+    let ids = watchedBroadcasts.get(workspace);
+    if (!ids) {
+        const watched = new Set();
+        watchedBroadcasts.set(workspace, watched);
+        ids = watched;
+        workspace.addChangeListener(event => {
+            if (event.type !== 'var_rename' || !event.varId || !watched.has(event.varId))
+                return;
+            const variable = project.targets.find(target => target.isStage)?.variables[event.varId];
+            if (variable?.type !== 'broadcast_msg' || variable.name !== event.newName || variable.value === variable.name)
+                return;
+            variable.value = variable.name;
+            for (const blocks of new Set(project.targets.map(target => target.blocks))) {
+                const pending = [...blocks.getScripts()];
+                const seen = new Set();
+                while (pending.length) {
+                    const id = pending.pop();
+                    if (!id || seen.has(id))
+                        continue;
+                    seen.add(id);
+                    const block = blocks.getBlock(id);
+                    if (!block)
+                        continue;
+                    const field = block.fields?.BROADCAST_OPTION;
+                    if (field?.id === event.varId)
+                        field.value = variable.name;
+                    if (block.next)
+                        pending.push(block.next);
+                    for (const input of Object.values(block.inputs ?? {})) {
+                        if (input.block)
+                            pending.push(input.block);
+                        if (input.shadow)
+                            pending.push(input.shadow);
+                    }
+                }
+            }
+            project.resetAllCaches?.();
+            project.emitProjectChanged?.();
+        });
+    }
+    ids.add(id);
+}
+function validName(value) {
+    return Boolean(value.trim()) && value === value.trim() && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+/** Rename a message from the message section, where no block result carries the edit. */
+export function renameProjectMessage(project, workspace, id, next) {
+    if (workspace.options.readOnly || workspace.isDragging())
+        return 'read-only';
+    const owner = project.targets.find(target => Object.hasOwn(target.variables, id));
+    const variable = owner?.variables[id];
+    if (variable?.type !== 'broadcast_msg' || workspace.getVariableById(id)?.name !== variable.name)
+        return 'stale';
+    if (!validName(next))
+        return 'invalid';
+    const match = next.toLocaleLowerCase();
+    if (project.targets.some(target => Object.entries(target.variables).some(([other, candidate]) => other !== id && candidate.type === 'broadcast_msg' && candidate.name.toLocaleLowerCase() === match))) {
+        return 'conflict';
+    }
+    maintainBroadcastReferences(project, workspace, id);
+    workspace.renameVariableById(id, next);
+    return workspace.getVariableById(id)?.name === next ? 'applied' : 'conflict';
+}
+export function applyProjectSearchReplacement(project, workspace, Blockly, result, next) {
+    if (workspace.options.readOnly || workspace.isDragging() || !result.edit)
+        return 'read-only';
+    const { target, edit } = result;
+    if (!project.targets.includes(target) || ('block' in result && target.blocks.getBlock(result.block.id) !== result.block))
+        return 'stale';
+    if (edit.type === 'comment' && result.kind === 'comment') {
+        const current = target.comments?.[result.commentId];
+        if (current !== result.comment || current.text !== edit.text)
+            return 'stale';
+        const comment = current.blockId ? workspace.getBlockById(current.blockId)?.comment : workspace.getCommentById(result.commentId);
+        if (!comment || comment.getText() !== edit.text)
+            return 'stale';
+        comment.setText(next);
+        return 'applied';
+    }
+    if (edit.type === 'name') {
+        if (!('block' in result))
+            return 'stale';
+        const fieldName = result.kind === 'variable' ? 'VARIABLE' : result.kind === 'list' ? 'LIST' : 'BROADCAST_OPTION';
+        const field = result.block.fields?.[fieldName] ??
+            target.blocks.getBlock(result.block.inputs?.BROADCAST_INPUT?.block)?.fields?.[fieldName];
+        if (field?.id !== edit.id)
+            return 'stale';
+        const variable = edit.owner.variables[edit.id];
+        const model = workspace.getVariableById(edit.id);
+        if (!project.targets.includes(edit.owner) || !variable || variable.name !== edit.name || model?.name !== edit.name)
+            return 'stale';
+        if (!validName(next) || variable.isCloud)
+            return 'invalid';
+        const scope = edit.owner.isStage ? project.targets.filter(target => target.isOriginal) :
+            project.targets.filter(target => target === edit.owner || target.isStage);
+        const match = next.toLocaleLowerCase();
+        if (scope.some(target => Object.entries(target.variables).some(([id, candidate]) => id !== edit.id && (candidate.type ?? '') === edit.variableType && candidate.name.toLocaleLowerCase() === match)))
+            return 'conflict';
+        if (edit.variableType === 'broadcast_msg')
+            maintainBroadcastReferences(project, workspace, edit.id);
+        workspace.renameVariableById(edit.id, next);
+        return workspace.getVariableById(edit.id)?.name === next ? 'applied' : 'conflict';
+    }
+    if (edit.type === 'procedure') {
+        if (!('block' in result))
+            return 'stale';
+        const procedure = result.block.mutation?.proccode ??
+            target.blocks.getBlock(result.block.inputs?.custom_block?.block)?.mutation?.proccode;
+        if (procedure !== edit.name)
+            return 'stale';
+        if (!validName(next) || !next.replace(/%[sbn]/g, '').trim())
+            return 'invalid';
+        const prototype = Blockly.Procedures.getPrototypeBlock(edit.name, workspace);
+        if (!prototype)
+            return 'stale';
+        if (next !== edit.name && Blockly.Procedures.getPrototypeBlock(next, workspace))
+            return 'conflict';
+        const mutation = prototype.mutationToDom();
+        mutation.setAttribute('proccode', next);
+        Blockly.Procedures.mutateCallersAndPrototype(edit.name, workspace, mutation);
+        return 'applied';
+    }
+    if (edit.type === 'field' && 'block' in result) {
+        const { id, field: name, value } = edit;
+        if (id !== result.block.id && !Object.values(result.block.inputs ?? {}).some(input => input.block === id))
+            return 'stale';
+        const block = workspace.getBlockById(id);
+        const field = block?.getField(name);
+        if (!field || String(field.getValue()) !== value || String(target.blocks.getBlock(id)?.fields?.[name]?.value) !== value)
+            return 'stale';
+        const text = Boolean(field instanceof Blockly.FieldTextInput);
+        const dropdown = Boolean(field instanceof Blockly.FieldDropdown);
+        if (!block?.isEditable() || !(text || dropdown))
+            return 'read-only';
+        if (field instanceof Blockly.FieldNumber && (!next.trim() || !Number.isFinite(Number(next))))
+            return 'invalid';
+        if (dropdown && !field.getOptions?.().some(option => String(option[1]) === next))
+            return 'invalid';
+        const validated = field.callValidator(next);
+        if (validated === null || (validated !== undefined && String(validated) !== next))
+            return 'invalid';
+        field.setValue(next);
+        return String(field.getValue()) === next ? 'applied' : 'invalid';
+    }
+    return 'read-only';
+}

package/dist/project-search.d.ts

@@ -0,0 +1,136 @@
+type Field = {
+    id?: string;
+    value: unknown;
+};
+type Block = {
+    id: string;
+    opcode: string;
+    next?: string;
+    shadow?: boolean;
+    fields?: Record<string, Field>;
+    inputs?: Record<string, {
+        block?: string;
+        shadow?: string;
+    }>;
+    mutation?: {
+        proccode?: string;
+        blockInfo?: {
+            text?: string;
+        };
+    };
+};
+type Asset = {
+    name: string;
+};
+type Comment = {
+    text: string;
+    blockId?: string | null;
+};
+type Variable = {
+    name: string;
+    type?: string;
+    isCloud?: boolean;
+    value?: unknown;
+};
+type Target = {
+    id: string;
+    isStage: boolean;
+    isOriginal: boolean;
+    getName(): string;
+    getCostumes(): Asset[];
+    getSounds(): Asset[];
+    variables: Record<string, Variable>;
+    comments?: Record<string, Comment>;
+    blocks: {
+        getScripts(): string[];
+        getBlock(id: string | undefined): Block | undefined;
+    };
+};
+export type SearchProject = {
+    targets: Target[];
+    getLabelForOpcode?(opcode: string): {
+        category?: string;
+        label?: string;
+    } | undefined;
+    resetAllCaches?(): void;
+    emitProjectChanged?(): void;
+    on?(event: 'PROJECT_CHANGED', listener: () => void): void;
+    removeListener?(event: 'PROJECT_CHANGED', listener: () => void): void;
+};
+type BlockKind = 'block' | 'variable' | 'list' | 'message' | 'argument' | 'extension';
+type AssetKind = 'costume' | 'backdrop' | 'sound';
+export type SearchKind = BlockKind | AssetKind | 'comment' | 'yaml';
+export type VariableAccess = 'read' | 'write';
+export type VariableSearch = {
+    ownerId: string;
+    variableId: string;
+    access: VariableAccess;
+};
+export declare const variableAccessLabels: {
+    readonly read: readonly ["読み取り", "Read"];
+    readonly write: readonly ["変更", "Write"];
+};
+export type SearchEdit = {
+    type: 'field';
+    id: string;
+    field: string;
+    value: string;
+} | {
+    type: 'name';
+    id: string;
+    owner: Target;
+    name: string;
+    variableType: string;
+} | {
+    type: 'procedure';
+    name: string;
+} | {
+    type: 'comment';
+    text: string;
+};
+export type ProjectSearchResult = {
+    label: string;
+    target: Target;
+    detail?: string;
+    edit?: SearchEdit;
+} & ({
+    kind: BlockKind;
+    block: Block;
+    variableAccess?: VariableAccess;
+} | {
+    kind: AssetKind;
+    asset: Asset;
+} | {
+    kind: 'comment';
+    comment: Comment;
+    commentId: string;
+});
+export type YamlSearchDocument = {
+    reference: {
+        providerId: string;
+        documentId: string;
+    };
+    filename: string;
+    source: string;
+};
+export type YamlSearchResult = {
+    kind: 'yaml';
+    document: YamlSearchDocument;
+    label: string;
+    detail: string;
+    range: {
+        start: number;
+        end: number;
+        expectedText: string;
+    };
+};
+export type SearchResult = ProjectSearchResult | YamlSearchResult;
+export declare const literalSearchPattern: (query: string, flags: string) => RegExp;
+export declare function countVariableAccesses(project: SearchProject, ownerId: string): Map<string, Record<VariableAccess, number>>;
+export declare function searchProject(project: SearchProject, messages: Record<string, string>, query: string, japanese: boolean, kinds?: ReadonlySet<SearchKind>, variableSearch?: VariableSearch): {
+    kind: SearchKind;
+    title: string;
+    results: ProjectSearchResult[];
+}[];
+export declare function searchYamlDocuments(documents: readonly YamlSearchDocument[], query: string, japanese: boolean): YamlSearchResult[];
+export {};