@kubohiroya/turbowarp-plus-editor-project-folder 0.15.1 → 0.17.0

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.
package/src/index.ts CHANGED
@@ -2,15 +2,16 @@ import {FolderError} from './source.js';
2
2
  import {createFolderSession} from './session.js';
3
3
  import {isProjectFolderEmpty} from './create-folder.js';
4
4
  import {registerFolder} from './folder-registry.js';
5
+ import type {ProjectFolderLocation} from './folder-registry.js';
5
6
  import {openBrowserProjects} from './browser-projects.js';
6
7
  import type {BrowserProjects} from './browser-projects.js';
7
8
  import {chooseBrowserProject} from './browser-project-dialog.js';
8
- import type {FolderHost, FolderVM, PickerWindow} from './session.js';
9
+ import type {Chosen, FolderHost, FolderVM, PickerWindow} from './session.js';
9
10
 
10
11
  export type {Comparison, ComparisonRequest, ComparisonSection, FolderHost, FolderScreenState, FolderVM, OpenResult} from './session.js';
11
12
  export type {ReloadTarget} from './block-reload.js';
12
13
  export {followProjectFolder} from './folder-registry.js';
13
- export type {FollowedFolder} from './folder-registry.js';
14
+ export type {FollowedFolder, ProjectFolderLocation} from './folder-registry.js';
14
15
  export type {DeserializeBlocks} from './script-reload.js';
15
16
  export {createProjectFolder, projectFolderOverwriteWarning} from './create-folder.js';
16
17
  export {openBrowserProjects} from './browser-projects.js';
@@ -21,7 +22,8 @@ export {zipDirectory} from './zip.js';
21
22
 
22
23
  const messages = {
23
24
  en: {
24
- open: 'Open Project Folder…', save: 'Save to Project Folder', openBrowser: 'Open Project Folder in This Browser…',
25
+ open: 'Open Folder…', save: 'Save to Project Folder', openBrowser: 'Open Folder Saved in This Browser…',
26
+ deviceUnavailable: 'This browser cannot open folders on your device. Use Chrome or Edge, or open a folder saved in this browser.',
25
27
  replace: 'Replace the open project and discard its unsaved changes?',
26
28
  opened: 'Project folder opened.', saved: 'Project folder saved.', unchanged: 'No changes to save.',
27
29
  sourceRemoved: (ids: string[]) => `Removed source metadata for replaced extensions: ${ids.join(', ')}. Use sb3-toolchain to fetch the managed sources again if you need to keep their provenance.`,
@@ -42,7 +44,8 @@ const messages = {
42
44
  full: 'These changes need the whole project to be reloaded.'
43
45
  },
44
46
  ja: {
45
- open: 'プロジェクトフォルダを開く…', save: 'プロジェクトフォルダに保存', openBrowser: 'ブラウザー内のプロジェクトフォルダを開く…',
47
+ open: 'フォルダを開く…', save: 'プロジェクトフォルダに保存', openBrowser: 'ブラウザーに保存したフォルダを開く…',
48
+ deviceUnavailable: 'このブラウザーでは端末のフォルダを開けません。Chrome か Edge を使うか、ブラウザーに保存したフォルダを開いてください。',
46
49
  replace: '未保存の変更を破棄して、別の作品を開きますか?',
47
50
  opened: 'プロジェクトフォルダを開きました。', saved: 'プロジェクトフォルダに保存しました。', unchanged: '保存する変更はありません。',
48
51
  sourceRemoved: (ids: string[]) => `差し替えた拡張機能(${ids.join('、')})の出どころ情報を削除しました。出どころを保つには、sb3-toolchain で拡張機能を取得し直してください。`,
@@ -73,8 +76,10 @@ interface MenuProps {
73
76
  onRequestClose(): void;
74
77
  }
75
78
  type MenuEntry = {session: ReturnType<typeof createFolderSession>; open(locale: string): void; save(locale: string): void;
76
- /** Opens a folder kept in this browser, when the host shows it beside the folder picker. */
77
- openBrowser?(locale: string): void};
79
+ /** Opens a folder kept in this browser, wherever the browser's folders are available. */
80
+ openBrowser?(locale: string): void;
81
+ /** Whether the browser can pick folders on the device; without it, Open uses the browser's folders. */
82
+ deviceFolders: boolean};
78
83
  const menus = new WeakMap<FolderVM, MenuEntry>();
79
84
 
80
85
  type ObserverWindow = PickerWindow & {FileSystemObserver?: new (callback: () => void) => {
@@ -109,13 +114,24 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
109
114
  const chooseBrowser = async (purpose: 'open' | 'create', title?: string) => {
110
115
  const choice = await chooseBrowserProject({document, projects: browserProjects!, locale, purpose, title});
111
116
  if (!choice) throw abort();
112
- return choice.directory;
117
+ return choice;
118
+ };
119
+ // A folder kept in the browser was chosen as a whole, so its stored folder is the root even when the project is inside.
120
+ const chooseBrowserFolder = async (): Promise<Chosen> => {
121
+ const {project, directory} = await chooseBrowser('open');
122
+ return {directory, root: await browserProjects!.root(project.id).catch(() => null) ?? directory};
113
123
  };
114
124
  const pickDirectory = devicePicker ?
115
- (options: {id: string; mode: 'readwrite'}) => devicePicker.call(view, options) :
116
- () => chooseBrowser('open');
117
- const pickNewDirectory = (options: {id: string; mode: 'readwrite'}, title?: string) =>
118
- devicePicker ? devicePicker.call(view, options) : chooseBrowser('create', title);
125
+ async (options: {id: string; mode: 'readwrite'}): Promise<Chosen> => ({directory: await devicePicker.call(view, options)}) :
126
+ chooseBrowserFolder;
127
+ const locations: ProjectFolderLocation[] = [];
128
+ if (devicePicker) locations.push('device');
129
+ if (browserProjects) locations.push('browser');
130
+ const pickNewDirectory = async (options: {id: string; mode: 'readwrite'}, title?: string,
131
+ location: ProjectFolderLocation = devicePicker ? 'device' : 'browser') => {
132
+ if (!locations.includes(location)) throw new FolderError('unsupported');
133
+ return location === 'device' ? devicePicker!.call(view, options) : (await chooseBrowser('create', title)).directory;
134
+ };
119
135
  /** Runs `run` with the browser folder of `directory` locked against other tabs, and marks it as updated. */
120
136
  const withBrowserProject = async <T>(directory: FileSystemDirectoryHandle | null, run: () => Promise<T>) => {
121
137
  const project = directory && browserProjects ? await browserProjects.find(directory).catch(() => null) : null;
@@ -271,6 +287,7 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
271
287
  };
272
288
  }
273
289
  const menu: MenuEntry = {
290
+ deviceFolders: typeof devicePicker === 'function',
274
291
  session,
275
292
  open(locale) {
276
293
  const message = messageFor(locale);
@@ -278,9 +295,9 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
278
295
  .then(result => {if (result === 'opened') report(message.opened);}, error => fail(locale, error)).finally(renderReload);
279
296
  renderReload();
280
297
  },
281
- openBrowser: devicePicker && browserProjects ? locale => {
298
+ openBrowser: browserProjects ? locale => {
282
299
  const message = messageFor(locale);
283
- session.open(() => chooseBrowser('open'), () => view.confirm(message.replace))
300
+ session.open(chooseBrowserFolder, () => view.confirm(message.replace))
284
301
  .then(result => {if (result === 'opened') report(message.opened);}, error => fail(locale, error)).finally(renderReload);
285
302
  renderReload();
286
303
  } : undefined,
@@ -303,6 +320,8 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
303
320
  menus.set(vm, menu);
304
321
  const unregister = registerFolder(vm, {
305
322
  get directory() {return session.directory;},
323
+ get root() {return session.root;},
324
+ locations,
306
325
  subscribe: listener => session.subscribe(listener),
307
326
  subscribeEdits: listener => session.subscribeEdits(listener),
308
327
  unsavedPaths: () => session.unsavedPaths(),
@@ -322,19 +341,21 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
322
341
  * Creates a project folder from a snapshot. `title` names a folder made in the browser, where the user names a
323
342
  * new folder instead of picking one on the device.
324
343
  */
325
- createFromSnapshot({prepareFiles, collectEdits, directory, current = () => true, title}: {
344
+ createFromSnapshot({prepareFiles, collectEdits, directory, current = () => true, title, location}: {
326
345
  prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>;
327
346
  collectEdits?: () => Promise<void>;
328
347
  directory?: FileSystemDirectoryHandle;
329
348
  current?: () => boolean;
330
349
  title?: string;
350
+ /** Explicit destination; omitted uses the device picker when available. */
351
+ location?: ProjectFolderLocation;
331
352
  }) {
332
353
  const message = locale.startsWith('ja') ?
333
354
  '指定されたフォルダは空ではありません。フォルダに保存されている内容が上書きされる場合があります。よろしいですか?' :
334
355
  'The selected folder is not empty. Contents in the folder may be overwritten. Continue?';
335
356
  return session.createFromSnapshot(async () => {
336
357
  try {
337
- const selected = directory ?? await pickNewDirectory({id: 'turbowarp-plus-project-folder', mode: 'readwrite'}, title);
358
+ const selected = directory ?? await pickNewDirectory({id: 'turbowarp-plus-project-folder', mode: 'readwrite'}, title, location);
338
359
  if (!current()) return null;
339
360
  const overwrite = !await isProjectFolderEmpty(selected);
340
361
  if (!current() || (overwrite && !view.confirm(message))) return null;
@@ -351,6 +372,11 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
351
372
  * detached. A host can tell projects apart by it, for example to keep the layout of each one.
352
373
  */
353
374
  get directory() {return session.directory;},
375
+ /**
376
+ * The folder the user chose for the loaded project, or `null` like `directory`. It is `directory` itself, or
377
+ * the repository whose `project` folder holds the project, or the stored folder of a folder kept in the browser.
378
+ */
379
+ get root() {return session.root;},
354
380
  dispose() {
355
381
  menus.delete(vm);
356
382
  unregister();
@@ -368,6 +394,8 @@ export function projectFolderActions(vm: FolderVM, locale = 'en') {
368
394
  return {
369
395
  open: () => entry.open(locale),
370
396
  openBrowser: entry.openBrowser ? () => entry.openBrowser!(locale) : undefined,
397
+ /** Whether Open can pick a folder on the device. Safari and Firefox cannot, so hosts show Open as unavailable. */
398
+ deviceFolders: entry.deviceFolders,
371
399
  save: entry.session.canSave ? () => entry.save(locale) : undefined,
372
400
  detach: () => entry.session.detach()
373
401
  };
@@ -380,6 +408,12 @@ export function renderProjectFolderMenu(createElement: MenuElement, {
380
408
  if (!entry) return null;
381
409
  const labels = locale.startsWith('ja') ? messages.ja : messages.en;
382
410
  const item = (action: 'open' | 'openBrowser' | 'save') => {
411
+ // Without the device's folder picker, Open is shown but unavailable; the browser's folders have their own item.
412
+ if (action === 'open' && !entry.deviceFolders) {
413
+ return createElement(MenuItem, {command: `project-folder-${action}`},
414
+ createElement('span', {role: 'button', tabIndex: -1, 'aria-disabled': true, title: labels.deviceUnavailable,
415
+ style: {opacity: 0.5, cursor: 'default'}}, labels[action]));
416
+ }
383
417
  const run = () => {onRequestClose(); entry[action]!(locale);};
384
418
  return createElement(MenuItem, {command: `project-folder-${action}`, onClick: run},
385
419
  createElement('span', {role: 'button', tabIndex: 0, onKeyDown(event: KeyboardEvent) {
package/src/session.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import {assetKey, assetTypeFor, assertFolderUnchanged, collapsePalette, encodePalette, expandPalette, extensionsFile, fileVersion,
2
- equal, FolderError, manifestFile, paletteFile, parseProject, planExtensionSave, projectAssets, projectChanges, projectFile, readFolder,
2
+ equal, FolderError, manifestFile, paletteFile, parseProject, planExtensionSave, projectAssets, projectChanges, projectFile, readProjectFolder,
3
3
  readFolderUpdate, sameBytes, unsupported} from './source.js';
4
4
  import type {Asset, AssetKind, FolderSource, FolderUpdate, JsonObject, Project, Storage} from './source.js';
5
5
  import {applyBlockReload, planBlockReload} from './block-reload.js';
@@ -131,7 +131,9 @@ type Edits = {kind: 'values'; changes: ReturnType<typeof planBlockReload>} |
131
131
  {kind: 'scripts'; changes: ReturnType<typeof planScriptReload>};
132
132
  type PendingUpdate = {update: FolderUpdate; edits: Edits | null; stable: boolean};
133
133
  type Pending = PendingUpdate | 'structure' | 'waiting';
134
- type Session = {source: FolderSource; baseline: Project; ids: string[] | undefined; stage: object; pending: Pending | null};
134
+ /** The folder to open, and the folder the user chose for it, which defaults to `directory`. */
135
+ export type Chosen = {directory: FileSystemDirectoryHandle; root?: FileSystemDirectoryHandle};
136
+ type Session = {source: FolderSource; root: FileSystemDirectoryHandle; baseline: Project; ids: string[] | undefined; stage: object; pending: Pending | null};
135
137
  /**
136
138
  * `ready`: the change can be applied in place: values and positions, or with `deserializeBlocks`, whole scripts. `full`: the change needs the whole project reloaded.
137
139
  * `waiting`: an external write looks incomplete and is checked again. `dirty`, `running` and `busy` hold the change.
@@ -274,20 +276,20 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
274
276
  unregisterTree?.();
275
277
  };
276
278
  const openFrom = async (
277
- getDirectory: () => Promise<FileSystemDirectoryHandle | null>,
279
+ getDirectory: () => Promise<Chosen | null>,
278
280
  confirmReplace: () => boolean,
279
281
  prepare: (directory: FileSystemDirectoryHandle) => Promise<FolderSource | null> =
280
- directory => readFolder(directory, vm.runtime.storage),
282
+ directory => readProjectFolder(directory, vm.runtime.storage),
281
283
  stillCurrent = () => true
282
284
  ): Promise<OpenResult> => {
283
285
  if (disposed || busy) return 'cancelled';
284
286
  busy = true;
285
287
  const priorStage = vm.runtime.getTargetForStage();
286
288
  try {
287
- const directory = await getDirectory();
288
- if (!directory || disposed) return 'cancelled';
289
+ const chosen = await getDirectory();
290
+ if (!chosen || disposed) return 'cancelled';
289
291
  const storage = vm.runtime.storage;
290
- const source = await prepare(directory);
292
+ const source = await prepare(chosen.directory);
291
293
  if (!source || disposed || !stillCurrent() || vm.runtime.getTargetForStage() !== priorStage) return 'cancelled';
292
294
  if (host.isProjectDirty() && !confirmReplace()) return 'cancelled';
293
295
  host.beforeLoad();
@@ -296,6 +298,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
296
298
  const assets = source.storageAssets;
297
299
  reader.assets = assets;
298
300
  let stage: object | null;
301
+ // The project may be the `project` folder inside the chosen one.
302
+ const directory = source.directory;
299
303
  pendingTree = undefined;
300
304
  expectingTree = true;
301
305
  try {
@@ -307,9 +311,9 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
307
311
  if (reader.assets === assets) reader.assets = null;
308
312
  }
309
313
  if (disposed || !stage || vm.runtime.getTargetForStage() !== stage) return 'cancelled';
310
- host.onOpened(directory.name);
314
+ host.onOpened(chosen.directory.name);
311
315
  const baseline = snapshot();
312
- setCurrent({source, stage, baseline, ids: identify(baseline), pending: null});
316
+ setCurrent({source, root: chosen.root ?? chosen.directory, stage, baseline, ids: identify(baseline), pending: null});
313
317
  // The tree may come with the load or right after it; once the folder is current, it is written there.
314
318
  expectingTree = false;
315
319
  if (pendingTree) writeExplorerState(directory, pendingTree, true);
@@ -432,6 +436,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
432
436
  return typeof pending === 'object' && pending !== null ? pending.update.version : null;
433
437
  },
434
438
  get directory() {return current?.source.directory ?? null;},
439
+ /** The folder the user chose: `directory` itself, or the repository whose `project` folder it is. */
440
+ get root() {return current?.root ?? null;},
435
441
  async mutate(directory: FileSystemDirectoryHandle, operation: (guard: () => void) => Promise<void>) {
436
442
  const session = current;
437
443
  if (!session || busy || session.source.directory !== directory) throw new FolderError('conflict');
@@ -528,9 +534,11 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
528
534
  if (!session || !session.pending || session.pending === 'waiting' || host.blockReload?.isRunning()) {
529
535
  return Promise.resolve('cancelled');
530
536
  }
531
- return openFrom(() => Promise.resolve(current === session ? session.source.directory : null), confirmReplace);
537
+ return openFrom(() => Promise.resolve(current === session ? {directory: session.source.directory, root: session.root} : null),
538
+ confirmReplace);
532
539
  },
533
- open(pick: FileSystemPicker, confirmReplace: () => boolean): Promise<OpenResult> {
540
+ /** `pick` gives the folder to open and, when it differs, the folder the user chose as `root`. */
541
+ open(pick: (options: {id: string; mode: 'readwrite'}) => Promise<Chosen>, confirmReplace: () => boolean): Promise<OpenResult> {
534
542
  return openFrom(async () => {
535
543
  try {
536
544
  return await pick({id: 'turbowarp-plus-project-folder', mode: 'readwrite'});
@@ -540,8 +548,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
540
548
  }
541
549
  }, confirmReplace);
542
550
  },
543
- openDirectory(directory: FileSystemDirectoryHandle, confirmReplace: () => boolean): Promise<OpenResult> {
544
- return openFrom(() => Promise.resolve(directory), confirmReplace);
551
+ /**
552
+ * Opens `directory`, or its `project` folder when it has no project of its own. `root` is the folder the user
553
+ * chose, for a host that located the project itself; it defaults to `directory`.
554
+ */
555
+ openDirectory(directory: FileSystemDirectoryHandle, confirmReplace: () => boolean,
556
+ root?: FileSystemDirectoryHandle): Promise<OpenResult> {
557
+ return openFrom(() => Promise.resolve({directory, root}), confirmReplace);
545
558
  },
546
559
  createFromSnapshot(selectDestination: () => Promise<{directory: FileSystemDirectoryHandle; overwrite: boolean} | null>,
547
560
  prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>, isCurrent: () => boolean): Promise<OpenResult> {
@@ -553,7 +566,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
553
566
  return openFrom(async () => {
554
567
  const destination = await selectDestination();
555
568
  overwrite = destination?.overwrite ?? false;
556
- return destination?.directory ?? null;
569
+ return destination ? {directory: destination.directory} : null;
557
570
  }, currentProject, async directory => {
558
571
  if (!currentProject()) return null;
559
572
  savedRevision = revision;
package/src/source.ts CHANGED
@@ -374,6 +374,46 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
374
374
  palette: paletteDocument};
375
375
  }
376
376
 
377
+ /** The project folder inside a repository, as Project Starter makes it. */
378
+ export const projectSubfolder = 'project';
379
+
380
+ const missingEntry = (error: unknown) => error instanceof DOMException && ['NotFoundError', 'TypeMismatchError'].includes(error.name);
381
+ /** Whether `directory` has an entry called `name`, a file or a folder. */
382
+ async function hasEntry(directory: FileSystemDirectoryHandle, name: string) {
383
+ for (const get of [() => directory.getFileHandle(name), () => directory.getDirectoryHandle(name)]) {
384
+ try {
385
+ await get();
386
+ return true;
387
+ } catch (error) {
388
+ if (!missingEntry(error)) throw error;
389
+ }
390
+ }
391
+ return false;
392
+ }
393
+
394
+ /**
395
+ * Reads the project in `directory`, or, when the folder has no project of its own, in its `project` folder, as in a
396
+ * repository whose project sits in `project/`. That folder must not be a repository itself. The error is the one
397
+ * for `directory` when neither holds a project.
398
+ */
399
+ export async function readProjectFolder(directory: FileSystemDirectoryHandle, storage: Storage): Promise<FolderSource> {
400
+ try {
401
+ return await readFolder(directory, storage);
402
+ } catch (error) {
403
+ const child = await (async () => {
404
+ if (await hasEntry(directory, projectFile) || await hasEntry(directory, manifestFile)) return null;
405
+ const found = await directory.getDirectoryHandle(projectSubfolder);
406
+ return await hasEntry(found, '.git') ? null : found;
407
+ })().catch(() => null);
408
+ if (!child) throw error;
409
+ try {
410
+ return await readFolder(child, storage);
411
+ } catch {
412
+ throw error;
413
+ }
414
+ }
415
+ }
416
+
377
417
  export const sameBytes = (a: Uint8Array, b: Uint8Array) => a.length === b.length && a.every((value, index) => value === b[index]);
378
418
 
379
419
  export type FolderUpdate = {version: string; bytes: Uint8Array; project: Project};