@kubohiroya/turbowarp-plus-editor-workbench 0.28.1 → 0.29.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,330 @@
1
+ import { flushPendingSurfaceEdits } from '@kubohiroya/turbowarp-plus-editor-windows/surfaces';
2
+ import { createProjectCatalogStore } from './project-catalog.js';
3
+ import { openProjectCatalog } from './project-catalog-dialog.js';
4
+ import { importWorkspaceProjectHistory } from './project-catalog-migration.js';
5
+ import { withProjectSerialization } from '@kubohiroya/turbowarp-extension-loader/scratch-vm';
6
+ import { PROJECT_INFO_KEY } from './project-tools/properties.js';
7
+ async function permission(handle, mode) {
8
+ const access = handle;
9
+ if (!access.queryPermission || await access.queryPermission({ mode }) === 'granted')
10
+ return;
11
+ if (!access.requestPermission || await access.requestPermission({ mode }) !== 'granted') {
12
+ throw new DOMException('Permission was not granted', 'NotAllowedError');
13
+ }
14
+ }
15
+ const same = async (a, b) => {
16
+ try {
17
+ return Boolean(a && b && await a.isSameEntry(b));
18
+ }
19
+ catch {
20
+ return false;
21
+ }
22
+ };
23
+ /** Connects native resources to the catalog without importing GUI code or changing the saved project format. */
24
+ export function createProjectCatalogRuntime(ports) {
25
+ const { document, vm, properties } = ports;
26
+ const view = document.defaultView;
27
+ const store = ports.store ?? createProjectCatalogStore({ indexedDB: view.indexedDB, locks: view.navigator.locks });
28
+ let folders;
29
+ let storage;
30
+ let activeId;
31
+ let alive = true;
32
+ let performing = false;
33
+ let selectedFile;
34
+ let observedSequence = -1;
35
+ let observedFile = null;
36
+ let timer;
37
+ let dialog;
38
+ let tracking = Promise.resolve();
39
+ const report = (error) => ports.report?.(error);
40
+ const title = () => properties.snapshot().title;
41
+ const askReplace = (locale) => !ports.isDirty() || view.confirm(locale.startsWith('ja') ?
42
+ '現在の作品に未保存の変更があります。選んだ作品を開きますか?' :
43
+ 'The current project has unsaved changes. Open the selected project?');
44
+ const source = async (fallback) => {
45
+ const folder = folders?.folder;
46
+ const handle = folder?.directory ?? ports.readFile();
47
+ if (!handle)
48
+ return fallback?.location === 'file' ? { ...fallback, title: title() || fallback.title } : null;
49
+ const browser = handle.kind === 'directory' && folder?.browserProjects ? await folder.browserProjects.find(handle) : null;
50
+ const remote = handle.kind === 'directory' ? await folders?.readRemote?.(folder?.root ?? handle).catch(() => undefined) : undefined;
51
+ return { location: browser ? 'browser' : handle.kind === 'file' ? 'file' : 'folder',
52
+ title: title() || browser?.title || handle.name, storageName: browser?.title ?? handle.name,
53
+ handle, repositoryRoot: handle.kind === 'directory' ? folder?.root ?? undefined : undefined,
54
+ browserId: browser?.id, remote };
55
+ };
56
+ const capture = () => {
57
+ const load = properties.loadState();
58
+ const file = ports.readFile();
59
+ if (!alive || performing || properties.snapshot().loading || load.phase === 'failed')
60
+ return;
61
+ if (load.sequence === observedSequence && file === observedFile)
62
+ return;
63
+ observedSequence = load.sequence;
64
+ observedFile = file;
65
+ if (load.phase !== 'loaded')
66
+ return;
67
+ const selection = selectedFile?.sequence === load.sequence ? selectedFile.file : undefined;
68
+ tracking = tracking.catch(() => { }).then(async () => {
69
+ if (!alive || performing)
70
+ return;
71
+ const input = await source() ?? (selection ? { location: 'file', title: title() || selection.name,
72
+ storageName: selection.name } : null);
73
+ if (input)
74
+ activeId = (await store.register(input)).id;
75
+ else
76
+ activeId = undefined;
77
+ }).catch(report);
78
+ };
79
+ const schedule = () => {
80
+ if (!alive)
81
+ return;
82
+ view.clearTimeout(timer);
83
+ // Folder onOpened and the GUI's upload completion publish their location after loadProject resolves.
84
+ timer = view.setTimeout(capture, 0);
85
+ };
86
+ const stopLoad = properties.subscribe(schedule);
87
+ const stopLocation = ports.subscribeLocation?.(schedule);
88
+ const withAction = async (run) => {
89
+ if (performing)
90
+ throw new Error('Another project operation is in progress');
91
+ performing = true;
92
+ try {
93
+ await tracking;
94
+ return await run();
95
+ }
96
+ finally {
97
+ performing = false;
98
+ observedSequence = properties.loadState().sequence;
99
+ observedFile = ports.readFile();
100
+ }
101
+ };
102
+ const chooseFile = (project) => {
103
+ const picker = view.showOpenFilePicker;
104
+ if (picker)
105
+ return picker({ multiple: false, types: [{ description: project.storageName, accept: { '*/*': ['.sb3'] } }] })
106
+ .then(async ([handle]) => ({ handle, file: await handle.getFile() }));
107
+ return new Promise(resolve => {
108
+ const input = document.createElement('input');
109
+ input.type = 'file';
110
+ input.accept = '.sb3';
111
+ input.hidden = true;
112
+ const finish = (value) => { input.remove(); resolve(value); };
113
+ input.addEventListener('change', () => finish(input.files?.[0] ? { file: input.files[0] } : null), { once: true });
114
+ input.addEventListener('cancel', () => finish(null), { once: true });
115
+ document.body.append(input);
116
+ input.click();
117
+ });
118
+ };
119
+ const open = async (project, locale) => {
120
+ await flushPendingSurfaceEdits();
121
+ const folder = folders?.folder;
122
+ if (project.location === 'remote' || (!project.handle && project.remote && project.location !== 'browser')) {
123
+ if (!folders?.openRemote || !await folders.openRemote(locale, project.remote))
124
+ return null;
125
+ }
126
+ else if (project.location === 'browser' || project.handle?.kind === 'directory') {
127
+ if (!folder)
128
+ throw new Error('Project folders are unavailable');
129
+ const directory = project.browserId ? await folder.browserProjects?.root(project.browserId) : project.handle;
130
+ if (!directory) {
131
+ if (project.remote && folders?.openRemote && await folders.openRemote(locale, project.remote))
132
+ return source(project);
133
+ throw new DOMException('The saved folder no longer exists', 'NotFoundError');
134
+ }
135
+ await permission(directory, 'read');
136
+ if (project.browserId)
137
+ await folder.browserProjects.moveProjectToRoot(project.browserId);
138
+ if (await folder.openDirectory(directory, () => askReplace(locale), project.repositoryRoot) !== 'opened')
139
+ return null;
140
+ }
141
+ else {
142
+ if (!askReplace(locale))
143
+ return null;
144
+ let handle = project.handle;
145
+ let file;
146
+ if (handle) {
147
+ await permission(handle, 'read');
148
+ try {
149
+ file = await handle.getFile();
150
+ }
151
+ catch (error) {
152
+ if (error.name !== 'NotFoundError')
153
+ throw error;
154
+ const chosen = await chooseFile(project);
155
+ if (!chosen)
156
+ return null;
157
+ file = chosen.file;
158
+ handle = chosen.handle;
159
+ }
160
+ }
161
+ else {
162
+ const chosen = await chooseFile(project);
163
+ if (!chosen)
164
+ return null;
165
+ file = chosen.file;
166
+ handle = chosen.handle;
167
+ }
168
+ if (!storage)
169
+ throw new Error('File loading is unavailable');
170
+ vm.quit();
171
+ await vm.loadProject(await file.arrayBuffer(), { replaceLegacyExtensions: true });
172
+ folder?.detach();
173
+ storage.finish(handle ?? null, properties.loadedTitle?.() || file.name.replace(/\.sb3$/i, ''), true);
174
+ vm.renderer?.draw();
175
+ activeId = project.id;
176
+ return { location: 'file', title: title() || project.title, storageName: file.name, handle };
177
+ }
178
+ activeId = project.id;
179
+ return source(project);
180
+ };
181
+ const ensureOpen = async (project, locale) => {
182
+ if (activeId === project.id && (await same(project.handle, folders?.folder.directory ?? ports.readFile()) ||
183
+ project.location === 'file' && !project.handle))
184
+ return true;
185
+ const opened = await open(project, locale);
186
+ if (!opened)
187
+ return false;
188
+ await store.register(opened, true, project.id);
189
+ return true;
190
+ };
191
+ const operations = (project, locale) => {
192
+ const ja = locale.startsWith('ja');
193
+ const handle = project.handle;
194
+ const browser = project.browserId && folders?.folder.browserProjects;
195
+ const noStorage = ja ? 'この保存先では名前変更・削除を実行できません。' :
196
+ 'This storage does not support renaming or deleting the saved resource.';
197
+ const remoteNote = ja ? 'GitHubのリポジトリ名変更は別途対応が必要です(#681)。' :
198
+ 'Renaming the repository on GitHub requires the rename support tracked in #681.';
199
+ const unsupported = { renameStorage: project.location === 'remote' ? remoteNote : noStorage,
200
+ deleteData: project.location === 'remote' ? (ja ? 'リモートの登録は「一覧から除外」で解除できます。' :
201
+ 'Use Remove from List to forget a remote repository.') : noStorage };
202
+ if (browser || handle?.move)
203
+ delete unsupported.renameStorage;
204
+ const canDelete = Boolean((browser || handle?.remove) && activeId !== project.id);
205
+ if (canDelete)
206
+ delete unsupported.deleteData;
207
+ else if (activeId === project.id)
208
+ unsupported.deleteData = ja ?
209
+ '別の作品を開いてから、この保存データを削除してください。' : 'Open another project before deleting this saved project.';
210
+ let canRenameProject = project.location !== 'file' || Boolean(handle ||
211
+ view.showOpenFilePicker);
212
+ if (!canRenameProject)
213
+ unsupported.renameProject = ja ?
214
+ 'このブラウザーでは元のSB3ファイルへ書き戻せません。開いてからコピーを保存できます。' :
215
+ 'This browser cannot overwrite the original SB3 file. Open it and save a copy instead.';
216
+ if (activeId === project.id && properties.snapshot().readOnly) {
217
+ canRenameProject = false;
218
+ unsupported.renameProject = ja ? 'この作品の情報は読み取り専用です。' : 'This project information is read-only.';
219
+ }
220
+ return {
221
+ unavailable: { ...unsupported },
222
+ open: () => withAction(() => open(project, locale)),
223
+ ...canRenameProject && { renameProject: (nextTitle) => withAction(async () => {
224
+ if (!await ensureOpen(project, locale))
225
+ throw new DOMException('Cancelled', 'AbortError');
226
+ await flushPendingSurfaceEdits();
227
+ const stage = vm.runtime.getTargetForStage();
228
+ const current = () => stage === vm.runtime.getTargetForStage();
229
+ properties.apply({ title: nextTitle });
230
+ if (folders?.folder.directory)
231
+ await folders.folder.save();
232
+ else {
233
+ const file = ports.readFile();
234
+ if (!storage || !file)
235
+ throw new Error(ja ? '名前を保存するにはSB3ファイルの保存先を選択してください。' :
236
+ 'Select a writable SB3 file to save the project title.');
237
+ await permission(file, 'readwrite');
238
+ let commit;
239
+ let edited = false;
240
+ const changed = () => { edited = true; };
241
+ vm.on?.('PROJECT_CHANGED', changed);
242
+ try {
243
+ await storage.write(file, run => withProjectSerialization(vm, { deferCommit: action => { commit = action; } }, run), current);
244
+ if (!current())
245
+ throw new DOMException('The project changed', 'AbortError');
246
+ commit?.();
247
+ storage.finish(file, nextTitle, !edited);
248
+ }
249
+ finally {
250
+ vm.off?.('PROJECT_CHANGED', changed);
251
+ }
252
+ }
253
+ }) },
254
+ ...(browser || handle?.move ? { renameStorage: (name) => withAction(async () => {
255
+ if (!name.trim() || /[\\/\u0000-\u001f]/u.test(name) || name === '.' || name === '..') {
256
+ throw new Error(ja ? '保存先の名前に使えない文字が含まれています。' : 'The storage name is invalid.');
257
+ }
258
+ if (handle?.kind === 'file' && !/\.sb3$/i.test(name))
259
+ name += '.sb3';
260
+ if (browser)
261
+ await browser.exclusive(project.browserId, () => browser.rename(project.browserId, name));
262
+ else {
263
+ await permission(handle, 'readwrite');
264
+ await handle.move(name);
265
+ }
266
+ return { storageName: name, handle };
267
+ }) } : {}),
268
+ ...(canDelete ? { deleteData: () => withAction(async () => {
269
+ const currentHandle = folders?.folder.directory ?? ports.readFile();
270
+ if (activeId === project.id || await same(handle, currentHandle)) {
271
+ throw new Error(ja ? '別の作品を開いてから、この保存データを削除してください。' :
272
+ 'Open another project before deleting this saved project.');
273
+ }
274
+ if (browser)
275
+ await browser.remove(project.browserId);
276
+ else {
277
+ await permission(handle, 'readwrite');
278
+ await handle.remove({ recursive: handle.kind === 'directory' });
279
+ }
280
+ }) } : {})
281
+ };
282
+ };
283
+ const host = (locale) => ({ store, operations: project => operations(project, locale), async refresh() {
284
+ await tracking;
285
+ await importWorkspaceProjectHistory(store, view.indexedDB);
286
+ for (const entry of await folders?.folder.browserProjects?.list() ?? []) {
287
+ const handle = await folders.folder.browserProjects.root(entry.id);
288
+ if (!handle)
289
+ continue;
290
+ const existing = (await store.list(true)).find(project => project.browserId === entry.id);
291
+ let savedTitle;
292
+ if (!existing) {
293
+ try {
294
+ const file = await (await handle.getFileHandle('project.source.json')).getFile();
295
+ const info = file.size <= 32 * 1024 * 1024 ? JSON.parse(await file.text())[PROJECT_INFO_KEY] : null;
296
+ if (info?.schemaVersion === 1 && typeof info.title === 'string')
297
+ savedTitle = info.title;
298
+ }
299
+ catch { /* A newly created or incomplete folder has no project metadata yet. */ }
300
+ }
301
+ await store.register({ location: 'browser', browserId: entry.id, handle, storageName: entry.title,
302
+ title: existing?.title ?? savedTitle ?? entry.title,
303
+ remote: existing?.remote ?? await folders?.readRemote?.(handle).catch(() => undefined) }, false);
304
+ }
305
+ } });
306
+ schedule();
307
+ return {
308
+ store,
309
+ bindFolder(value) { folders = value; schedule(); },
310
+ fileOpened(file) {
311
+ if (!file || !/\.sb3$/i.test(file.name))
312
+ return;
313
+ selectedFile = { file, sequence: properties.loadState().sequence };
314
+ schedule();
315
+ },
316
+ capture: schedule,
317
+ show(locale, fileStorage, createProject) {
318
+ storage = fileStorage;
319
+ dialog?.();
320
+ dialog = openProjectCatalog(document, { ...host(locale), createProject }, locale);
321
+ },
322
+ dispose() {
323
+ alive = false;
324
+ view.clearTimeout(timer);
325
+ stopLoad();
326
+ stopLocation?.();
327
+ dialog?.();
328
+ }
329
+ };
330
+ }
@@ -0,0 +1,3 @@
1
+ import type { ProjectCatalogStore } from './project-catalog.js';
2
+ /** Import existing handle history once per legacy record, without changing or creating a layout database. */
3
+ export declare function importWorkspaceProjectHistory(store: ProjectCatalogStore, factory?: IDBFactory): Promise<void>;
@@ -0,0 +1,47 @@
1
+ import { workspaceLayoutDatabase } from './workspace-layout-store.js';
2
+ /** Import existing handle history once per legacy record, without changing or creating a layout database. */
3
+ export async function importWorkspaceProjectHistory(store, factory) {
4
+ if (!factory)
5
+ return;
6
+ const records = await new Promise((resolve, reject) => {
7
+ const request = factory.open(workspaceLayoutDatabase);
8
+ let missing = false;
9
+ request.onupgradeneeded = () => { missing = true; request.transaction.abort(); };
10
+ request.onerror = () => missing ? resolve([]) : reject(request.error);
11
+ request.onsuccess = () => {
12
+ const db = request.result;
13
+ if (!db.objectStoreNames.contains('layouts')) {
14
+ db.close();
15
+ resolve([]);
16
+ return;
17
+ }
18
+ const transaction = db.transaction('layouts');
19
+ const read = transaction.objectStore('layouts').getAll();
20
+ transaction.oncomplete = () => { db.close(); resolve(read.result); };
21
+ transaction.onerror = transaction.onabort = () => { db.close(); reject(transaction.error); };
22
+ };
23
+ });
24
+ const known = await store.list(true);
25
+ for (const record of records) {
26
+ if (!Number.isSafeInteger(record.id) || !['file', 'directory'].includes(record.kind) || !record.handle ||
27
+ typeof record.name !== 'string' || known.some(project => project.legacyLayoutId === record.id))
28
+ continue;
29
+ let matched = false;
30
+ for (const project of known) {
31
+ try {
32
+ if (project.handle && await record.handle.isSameEntry(project.handle)) {
33
+ matched = true;
34
+ break;
35
+ }
36
+ }
37
+ catch { /* A missing resource can still have a legacy record, identified by its database id. */ }
38
+ }
39
+ if (matched)
40
+ continue;
41
+ const imported = await store.register({ location: record.kind === 'file' ? 'file' : 'folder',
42
+ title: record.kind === 'file' ? record.name.replace(/\.sb3$/i, '') : record.name,
43
+ storageName: record.name, handle: record.handle, legacyLayoutId: record.id,
44
+ lastOpenedAt: Number.isFinite(record.lastUsedAt) ? record.lastUsedAt : null }, false);
45
+ known.push(imported);
46
+ }
47
+ }
@@ -0,0 +1,58 @@
1
+ /** A catalog entry identifies a saved resource; its title never serves as its identity. */
2
+ export interface CatalogProject {
3
+ id: string;
4
+ title: string;
5
+ storageName: string;
6
+ location: 'file' | 'folder' | 'browser' | 'remote';
7
+ handle?: FileSystemFileHandle | FileSystemDirectoryHandle;
8
+ repositoryRoot?: FileSystemDirectoryHandle;
9
+ browserId?: string;
10
+ remote?: string;
11
+ legacyLayoutId?: number;
12
+ lastOpenedAt: number | null;
13
+ hidden?: boolean;
14
+ }
15
+ export type CatalogSource = Omit<CatalogProject, 'id' | 'lastOpenedAt' | 'hidden'> & {
16
+ lastOpenedAt?: number | null;
17
+ };
18
+ export type CatalogSort = {
19
+ by: 'title' | 'lastOpenedAt' | 'location';
20
+ direction: 'asc' | 'desc';
21
+ };
22
+ export interface ProjectCatalogStore {
23
+ list(includeHidden?: boolean): Promise<CatalogProject[]>;
24
+ register(source: CatalogSource, opened?: boolean, entryId?: string): Promise<CatalogProject>;
25
+ update(id: string, changes: Partial<Pick<CatalogProject, 'title' | 'storageName' | 'handle' | 'remote'>>): Promise<void>;
26
+ forget(id: string): Promise<void>;
27
+ remove(id: string): Promise<void>;
28
+ sort(value?: CatalogSort): Promise<CatalogSort>;
29
+ }
30
+ export declare const projectCatalogDatabase = "twPlusProjectCatalog";
31
+ /** Sorting never changes a caller's array; missing usage times stay last in either direction. */
32
+ export declare function sortCatalog(projects: readonly CatalogProject[], order: CatalogSort, locale?: string): CatalogProject[];
33
+ /** Persist handles by structured clone. The lock covers async handle comparisons outside IDB transactions. */
34
+ export declare function createProjectCatalogStore({ indexedDB, locks, now, id }?: {
35
+ indexedDB?: IDBFactory;
36
+ locks?: LockManager;
37
+ now?(): number;
38
+ id?(): string;
39
+ }): ProjectCatalogStore;
40
+ export interface CatalogOperations {
41
+ open(): Promise<CatalogSource | null>;
42
+ renameProject?(title: string): Promise<void>;
43
+ renameStorage?(name: string): Promise<Partial<Pick<CatalogProject, 'storageName' | 'handle' | 'remote'>>>;
44
+ deleteData?(): Promise<void>;
45
+ unavailable?: Partial<Record<'renameProject' | 'renameStorage' | 'deleteData', string>>;
46
+ }
47
+ export interface CatalogHost {
48
+ store: ProjectCatalogStore;
49
+ /** Opens the host's existing new-project flow after the catalog is dismissed. */
50
+ createProject?(): void;
51
+ refresh(): Promise<void>;
52
+ operations(project: CatalogProject): CatalogOperations;
53
+ }
54
+ /** Persist each successful step immediately, so a later failure cannot invent an atomic rename. */
55
+ export declare function renameCatalogProject(host: CatalogHost, project: CatalogProject, names: {
56
+ title?: string;
57
+ storageName?: string;
58
+ }): Promise<void>;
@@ -0,0 +1,150 @@
1
+ export const projectCatalogDatabase = 'twPlusProjectCatalog';
2
+ const defaultSort = { by: 'lastOpenedAt', direction: 'desc' };
3
+ const queues = new WeakMap();
4
+ const result = (request) => new Promise((resolve, reject) => {
5
+ request.onsuccess = () => resolve(request.result);
6
+ request.onerror = () => reject(request.error);
7
+ });
8
+ const finished = (transaction) => new Promise((resolve, reject) => {
9
+ transaction.oncomplete = () => resolve();
10
+ transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Catalog write failed'));
11
+ });
12
+ const isSort = (value) => value &&
13
+ ['title', 'lastOpenedAt', 'location'].includes(value.by) && ['asc', 'desc'].includes(value.direction);
14
+ /** Sorting never changes a caller's array; missing usage times stay last in either direction. */
15
+ export function sortCatalog(projects, order, locale = 'en') {
16
+ const compare = new Intl.Collator(locale, { numeric: true, sensitivity: 'base' }).compare;
17
+ return [...projects].sort((a, b) => {
18
+ if (order.by === 'lastOpenedAt' && (a.lastOpenedAt === null || b.lastOpenedAt === null)) {
19
+ if (a.lastOpenedAt !== b.lastOpenedAt)
20
+ return a.lastOpenedAt === null ? 1 : -1;
21
+ }
22
+ const primary = order.by === 'lastOpenedAt' ? (a.lastOpenedAt ?? 0) - (b.lastOpenedAt ?? 0) :
23
+ compare(a[order.by], b[order.by]);
24
+ return primary * (order.direction === 'asc' ? 1 : -1) || compare(a.title, b.title) || a.id.localeCompare(b.id);
25
+ });
26
+ }
27
+ /** Persist handles by structured clone. The lock covers async handle comparisons outside IDB transactions. */
28
+ export function createProjectCatalogStore({ indexedDB = globalThis.indexedDB, locks = globalThis.navigator?.locks, now = Date.now, id = () => globalThis.crypto.randomUUID() } = {}) {
29
+ let opened;
30
+ const database = () => opened ??= new Promise((resolve, reject) => {
31
+ if (!indexedDB)
32
+ return reject(new Error('IndexedDB is unavailable'));
33
+ const request = indexedDB.open(projectCatalogDatabase, 1);
34
+ request.onupgradeneeded = () => {
35
+ request.result.createObjectStore('projects', { keyPath: 'id' });
36
+ request.result.createObjectStore('preferences');
37
+ };
38
+ request.onerror = () => { opened = undefined; reject(request.error); };
39
+ request.onsuccess = () => {
40
+ request.result.onversionchange = () => { request.result.close(); opened = undefined; };
41
+ resolve(request.result);
42
+ };
43
+ });
44
+ const all = async () => {
45
+ const tx = (await database()).transaction('projects');
46
+ const done = finished(tx);
47
+ const records = await result(tx.objectStore('projects').getAll());
48
+ await done;
49
+ return records;
50
+ };
51
+ const write = async (record) => {
52
+ const tx = (await database()).transaction('projects', 'readwrite');
53
+ const done = finished(tx);
54
+ const table = tx.objectStore('projects');
55
+ if (typeof record === 'string')
56
+ table.delete(record);
57
+ else
58
+ table.put(record);
59
+ await done;
60
+ };
61
+ const serial = (run) => {
62
+ if (!indexedDB)
63
+ return Promise.reject(new Error('IndexedDB is unavailable'));
64
+ const pending = (queues.get(indexedDB) ?? Promise.resolve()).catch(() => { }).then(() => locks ? locks.request('tw-plus-project-catalog', run) : run());
65
+ queues.set(indexedDB, pending.catch(() => { }));
66
+ return pending;
67
+ };
68
+ const change = (key, update) => serial(async () => {
69
+ const record = (await all()).find(record => record.id === key);
70
+ if (!record)
71
+ throw new Error('The project is no longer in the catalog');
72
+ await write(update(record));
73
+ });
74
+ return {
75
+ async list(includeHidden = false) { return (await all()).filter(record => includeHidden || !record.hidden); },
76
+ register(source, opened = true, entryId) {
77
+ return serial(async () => {
78
+ const records = await all();
79
+ let existing = entryId ? records.find(record => record.id === entryId) : undefined;
80
+ for (const record of existing ? [] : records) {
81
+ if (source.legacyLayoutId !== undefined && record.legacyLayoutId === source.legacyLayoutId) {
82
+ existing = record;
83
+ break;
84
+ }
85
+ if (source.browserId && record.browserId === source.browserId) {
86
+ existing = record;
87
+ break;
88
+ }
89
+ if (source.handle && record.handle) {
90
+ try {
91
+ if (await source.handle.isSameEntry(record.handle)) {
92
+ existing = record;
93
+ break;
94
+ }
95
+ }
96
+ catch { /* Stale handle. */ }
97
+ }
98
+ // A remote-only entry has no worktree yet. Distinct worktrees of one remote stay distinct.
99
+ if (source.location === 'remote' && record.location === 'remote' && record.remote === source.remote) {
100
+ existing = record;
101
+ break;
102
+ }
103
+ }
104
+ const record = { ...existing, ...source, id: existing?.id ?? id(),
105
+ hidden: opened ? false : existing?.hidden ?? false,
106
+ lastOpenedAt: opened ? now() : existing?.lastOpenedAt ?? source.lastOpenedAt ?? null };
107
+ await write(record);
108
+ return record;
109
+ });
110
+ },
111
+ update(key, changes) { return change(key, record => ({ ...record, ...changes })); },
112
+ forget(key) { return change(key, record => ({ ...record, hidden: true })); },
113
+ remove(key) { return serial(() => write(key)); },
114
+ async sort(value) {
115
+ if (value && !isSort(value))
116
+ throw new Error('Invalid catalog order');
117
+ const tx = (await database()).transaction('preferences', value ? 'readwrite' : 'readonly');
118
+ const done = finished(tx);
119
+ const table = tx.objectStore('preferences');
120
+ const saved = value ? (table.put(value, 'sort'), value) : await result(table.get('sort'));
121
+ await done;
122
+ return isSort(saved) ? saved : { ...defaultSort };
123
+ }
124
+ };
125
+ }
126
+ /** Persist each successful step immediately, so a later failure cannot invent an atomic rename. */
127
+ export async function renameCatalogProject(host, project, names) {
128
+ if (names.title !== undefined && (!names.title.trim() || names.title.length > 100))
129
+ throw new Error('Invalid project name');
130
+ if (names.storageName !== undefined && (!names.storageName.trim() || names.storageName.length > 200))
131
+ throw new Error('Invalid storage name');
132
+ const actions = host.operations(project);
133
+ if (names.title !== undefined && !actions.renameProject || names.storageName !== undefined && !actions.renameStorage) {
134
+ throw new Error('This rename is unavailable');
135
+ }
136
+ if (names.title !== undefined) {
137
+ await actions.renameProject(names.title);
138
+ await host.store.update(project.id, { title: names.title });
139
+ }
140
+ if (names.storageName !== undefined) {
141
+ const current = (await host.store.list(true)).find(entry => entry.id === project.id);
142
+ if (!current)
143
+ throw new Error('The project is no longer in the catalog');
144
+ const rename = host.operations(current).renameStorage;
145
+ if (!rename)
146
+ throw new Error('This storage rename is unavailable');
147
+ const changes = await rename(names.storageName);
148
+ await host.store.update(project.id, changes);
149
+ }
150
+ }
@@ -35,6 +35,8 @@ export default function ProjectFileMenu({ locale, MenuItem, MenuSection, close,
35
35
  newProject?: NewProjectChoices;
36
36
  newWindow?: Action;
37
37
  open: Action;
38
+ /** Receives the same creation command as Create New Project, including its destination choices. */
39
+ catalog?: (createProject: Action) => void;
38
40
  externalYaml?: React.ReactNode;
39
41
  folder?: FolderActions;
40
42
  openRemote?: Action;
@@ -71,15 +71,16 @@ export default function ProjectFileMenu({ locale, MenuItem, MenuSection, close,
71
71
  };
72
72
  const e = entries;
73
73
  const createIn = e.createIn;
74
- const createNew = createIn ? ['new', ja ? '新しいプロジェクトを作成…' : 'Create New Project…', () => {
75
- if (typeof document === 'undefined')
76
- return;
77
- void openNewProjectDialog(document, locale, { ...e.newProject, create: e.create, createIn });
78
- }] : ['new', ja ? '新しいプロジェクトを作成' : 'Create New Project', e.create];
74
+ const createNew = createIn ? () => {
75
+ if (typeof document === 'undefined')
76
+ return;
77
+ void openNewProjectDialog(document, locale, { ...e.newProject, create: e.create, createIn });
78
+ } : e.create;
79
79
  return React.createElement(React.Fragment, null,
80
- item(createNew),
80
+ item(['new', ja ? `新しいプロジェクトを作成${createIn ? '…' : ''}` : `Create New Project${createIn ? '…' : ''}`, createNew]),
81
81
  e.newWindow && item(['window', ja ? '新しいウィンドウ' : 'New Window', e.newWindow]),
82
82
  React.createElement(MenuSection, null,
83
+ e.catalog && item(['projects', ja ? 'プロジェクト一覧…' : 'Projects…', () => e.catalog(createNew)]),
83
84
  item(['open', ja ? 'SB3ファイルを開く…' : 'Open SB3 File…', e.open]),
84
85
  e.folder && item(['project-folder-open', ja ? 'フォルダを開く…' : 'Open Folder…',
85
86
  e.folder.deviceFolders === false ? undefined : e.folder.open, false,
@@ -4,6 +4,7 @@ import type { createProjectDialogService } from './dialog.js';
4
4
  import type { NewProjectChoices, NewProjectRequest, NewProjectResult, ProjectFileStorage } from '../project-file-dialogs.js';
5
5
  import type { ProjectFolderWorkflows } from '../project-folder-workflows.js';
6
6
  import type { ProjectScreenState } from '../project-screen-state.js';
7
+ import type { CatalogFolderPorts } from '../project-catalog-host.js';
7
8
  export interface ProjectToolsPorts {
8
9
  installEditorExtensionHost(vm: any, settings: any): any;
9
10
  installProjectProperties: ReturnType<typeof createProjectProperties>;
@@ -19,9 +20,14 @@ export interface ProjectToolsPorts {
19
20
  isShown(): boolean;
20
21
  subscribe(listener: () => void): () => void;
21
22
  } | undefined;
23
+ catalogEnvironment?(document: Document): {
24
+ readFile(): FileSystemFileHandle | null;
25
+ isDirty(): boolean;
26
+ subscribeLocation(listener: () => void): () => void;
27
+ } | undefined;
22
28
  }
23
29
  /** Feature state and workflows are local to one host integration. */
24
- export declare function createProjectTools({ installEditorExtensionHost, installProjectProperties, createProjectDialogs, editorProjectArchives, projectToolsEnabled: PROJECT_TOOLS_ENABLED, manualProjectURIEnabled: MANUAL_PROJECT_URI_ENABLED, readStartupFlags: readWebStartupFeatureFlags, projectLoadState }: ProjectToolsPorts): {
30
+ export declare function createProjectTools({ installEditorExtensionHost, installProjectProperties, createProjectDialogs, editorProjectArchives, projectToolsEnabled: PROJECT_TOOLS_ENABLED, manualProjectURIEnabled: MANUAL_PROJECT_URI_ENABLED, readStartupFlags: readWebStartupFeatureFlags, projectLoadState, catalogEnvironment }: ProjectToolsPorts): {
25
31
  installProjectToolsHost: (vm: any, settings?: Parameters<typeof installEditorExtensionHost>[1] & Parameters<typeof installProjectProperties>[1], enabled?: boolean) => any;
26
32
  projectScreenState: (vm: any) => ProjectScreenState | undefined;
27
33
  loadedProjectTitle: (vm: any) => any;
@@ -62,4 +68,7 @@ export declare function createProjectTools({ installEditorExtensionHost, install
62
68
  onRequestClose: any;
63
69
  }) => React.CElement<null, React.Component<null, any, any>>;
64
70
  projectToolsOwnKeyEvent: (event: any) => boolean;
71
+ bindProjectCatalogFolder: (vm: object, ports: CatalogFolderPorts) => any;
72
+ projectCatalog: (vm: object, locale: string, storage: ProjectFileStorage, createProject?: () => void) => any;
73
+ projectFileOpened: (vm: object, file: File | null) => any;
65
74
  };