@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.13

package/bundled-types/host-app/services/recent-cards-service.ts

@@ -0,0 +1,174 @@
+import { registerDestructor } from '@ember/destroyable';
+import type Owner from '@ember/owner';
+import Service, { service } from '@ember/service';
+import { tracked, cached } from '@glimmer/tracking';
+
+import window from 'ember-window-mock';
+import { TrackedArray } from 'tracked-built-ins';
+
+import {
+  isCardInstance,
+  localId,
+  isLocalId,
+  trimJsonExtension,
+} from '@cardstack/runtime-common';
+
+import type { CardDef, BaseDef } from 'https://cardstack.com/base/card-api';
+import type * as CardAPI from 'https://cardstack.com/base/card-api';
+
+import { RecentCards } from '../utils/local-storage-keys';
+
+import type CardService from './card-service';
+import type RecentFilesService from './recent-files-service';
+import type ResetService from './reset';
+import type StoreService from './store';
+
+export interface RecentCard {
+  cardId: string;
+  timestamp?: number;
+}
+
+export default class RecentCardsService extends Service {
+  @service declare private reset: ResetService;
+  @service declare private cardService: CardService;
+  @service declare private recentFilesService: RecentFilesService;
+  @service declare private store: StoreService;
+  @tracked private ascendingRecentCards = new TrackedArray<RecentCard>([]);
+  private cachedAPI?: typeof CardAPI;
+  private addToRecentFiles = new Set<string>();
+  private pendingCardIdSubscriptions = new Map<string, CardDef>();
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.resetState();
+    this.reset.register(this);
+    registerDestructor(this, () => {
+      this.clearPendingCardIdSubscriptions();
+    });
+
+    const recentCardsString = window.localStorage.getItem(RecentCards);
+    if (recentCardsString) {
+      const recentCards: RecentCard[] = JSON.parse(recentCardsString).map(
+        (c: RecentCard | string) => ({
+          cardId: trimJsonExtension(typeof c === 'string' ? c : c.cardId),
+          timestamp: typeof c === 'string' ? Date.now() : c.timestamp,
+        }),
+      );
+      this.ascendingRecentCards.push(...recentCards);
+    }
+  }
+
+  @cached
+  // return in descending order: most recent to oldest
+  get recentCards(): RecentCard[] {
+    return [...this.ascendingRecentCards].reverse();
+  }
+
+  @cached
+  // return in descending order: most recent to oldest
+  get recentCardIds(): string[] {
+    return this.recentCards.map((c) => c.cardId);
+  }
+
+  resetState() {
+    this.clearPendingCardIdSubscriptions();
+    this.ascendingRecentCards = new TrackedArray([]);
+    this.addToRecentFiles.clear();
+  }
+
+  private findRecentCardIndex(id: string) {
+    return this.ascendingRecentCards.findIndex(
+      (item) => item.cardId === trimJsonExtension(id),
+    );
+  }
+
+  add(newId: string) {
+    if (isLocalId(newId)) {
+      let instance = this.store.peek(newId);
+      if (isCardInstance(instance)) {
+        this.addNewCard(instance);
+      }
+      return;
+    }
+
+    const existingCardIndex = this.findRecentCardIndex(newId);
+    if (existingCardIndex !== -1) {
+      this.ascendingRecentCards.splice(existingCardIndex, 1);
+    }
+    this.ascendingRecentCards.push({
+      cardId: newId,
+      timestamp: Date.now(),
+    });
+    if (this.ascendingRecentCards.length > 10) {
+      this.ascendingRecentCards.splice(0, 1);
+    }
+    window.localStorage.setItem(
+      RecentCards,
+      JSON.stringify(this.ascendingRecentCards),
+    );
+  }
+
+  async addNewCard(instance: CardDef, opts?: { addToRecentFiles?: true }) {
+    if (instance.id) {
+      this.add(instance.id);
+      if (opts?.addToRecentFiles) {
+        this.recentFilesService.addRecentFileUrl(instance.id);
+      }
+    } else {
+      this.cachedAPI = await this.cardService.getAPI();
+      if (this.pendingCardIdSubscriptions.has(instance[localId])) {
+        if (opts?.addToRecentFiles) {
+          this.addToRecentFiles.add(instance[localId]);
+        }
+        return;
+      }
+      if (opts?.addToRecentFiles) {
+        this.addToRecentFiles.add(instance[localId]);
+      }
+      this.pendingCardIdSubscriptions.set(instance[localId], instance);
+      this.cachedAPI.subscribeToChanges(instance, this.listenForCardId);
+    }
+  }
+
+  private listenForCardId = (instance: BaseDef, field: string) => {
+    if (field === 'id' && isCardInstance(instance) && instance.id) {
+      this.add(instance.id);
+      if (this.addToRecentFiles.has(instance[localId])) {
+        this.recentFilesService.addRecentFileUrl(`${instance.id}.json`);
+        this.addToRecentFiles.delete(instance[localId]);
+      }
+      this.pendingCardIdSubscriptions.delete(instance[localId]);
+      this.cachedAPI?.unsubscribeFromChanges(instance, this.listenForCardId);
+    }
+  };
+
+  remove(idToRemove: string) {
+    let index = this.findRecentCardIndex(idToRemove);
+    if (index === -1) {
+      return;
+    }
+    while (index !== -1) {
+      this.ascendingRecentCards.splice(index, 1);
+      index = this.findRecentCardIndex(idToRemove);
+    }
+    window.localStorage.setItem(
+      'recent-cards',
+      JSON.stringify(this.ascendingRecentCards),
+    );
+  }
+
+  private clearPendingCardIdSubscriptions() {
+    if (this.cachedAPI) {
+      for (let instance of this.pendingCardIdSubscriptions.values()) {
+        this.cachedAPI.unsubscribeFromChanges(instance, this.listenForCardId);
+      }
+    }
+    this.pendingCardIdSubscriptions.clear();
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'recent-cards-service': RecentCardsService;
+  }
+}

package/bundled-types/host-app/services/recent-files-service.ts

@@ -0,0 +1,224 @@
+import type Owner from '@ember/owner';
+import Service from '@ember/service';
+import { service } from '@ember/service';
+
+import { tracked } from '@glimmer/tracking';
+
+import window from 'ember-window-mock';
+import { TrackedArray } from 'tracked-built-ins';
+
+import { RealmPaths } from '@cardstack/runtime-common';
+import type { LocalPath } from '@cardstack/runtime-common/paths';
+
+import { RecentFiles } from '../utils/local-storage-keys';
+
+import type OperatorModeStateService from './operator-mode-state-service';
+import type ResetService from './reset';
+
+type SerialRecentFile = [URL, string, CursorPosition, number];
+
+export type CursorPosition = {
+  line: number;
+  column: number;
+};
+export interface RecentFile {
+  realmURL: URL;
+  filePath: LocalPath;
+  cursorPosition: CursorPosition | null;
+  timestamp?: number;
+}
+
+export default class RecentFilesService extends Service {
+  // we shouldn't be making assumptions about what realm the files are coming
+  // from, the caller should just tell us
+  @service declare private operatorModeStateService: OperatorModeStateService;
+  @service declare private reset: ResetService;
+
+  @tracked declare recentFiles: TrackedArray<RecentFile>;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.resetState();
+    this.reset.register(this);
+    this.extractRecentFilesFromStorage();
+  }
+
+  resetState() {
+    this.recentFiles = new TrackedArray([]);
+  }
+
+  removeRecentFile(file: LocalPath) {
+    let index = this.findRecentFileIndex(file);
+
+    if (index === -1) {
+      return;
+    }
+
+    while (index !== -1) {
+      this.recentFiles.splice(index, 1);
+      index = this.findRecentFileIndex(file);
+    }
+
+    this.persistRecentFiles();
+  }
+
+  removeRecentFilesForRealmURL(url: string) {
+    let realmURL = new RealmPaths(new URL(url)).url;
+    let removedAny = false;
+
+    for (let index = this.recentFiles.length - 1; index >= 0; index--) {
+      if (this.recentFiles[index].realmURL.href === realmURL) {
+        this.recentFiles.splice(index, 1);
+        removedAny = true;
+      }
+    }
+
+    if (removedAny) {
+      this.persistRecentFiles();
+    }
+  }
+
+  addRecentFileUrl(urlString: string) {
+    if (!urlString) {
+      return;
+    }
+    // TODO this wont work when visiting files that come from multiple realms in
+    // code mode...
+    let realmURL = this.operatorModeStateService.realmURL;
+
+    if (realmURL) {
+      let realmPaths = new RealmPaths(new URL(realmURL));
+      let url = new URL(urlString);
+
+      if (realmPaths.inRealm(url)) {
+        this.addRecentFile(realmPaths.local(url));
+      }
+    }
+  }
+
+  addRecentFile(file: LocalPath) {
+    // TODO this wont work when visiting files that come from multiple realms in
+    // code mode...
+    let currentRealmUrl = this.operatorModeStateService.realmURL;
+
+    if (!currentRealmUrl) {
+      return;
+    }
+
+    const existingIndex = this.findRecentFileIndex(file);
+
+    let cursorPosition;
+    if (existingIndex > -1) {
+      if (!cursorPosition) {
+        cursorPosition = this.recentFiles[existingIndex].cursorPosition;
+      }
+      this.recentFiles.splice(existingIndex, 1);
+    }
+
+    this.recentFiles.unshift({
+      realmURL: new URL(currentRealmUrl),
+      filePath: file,
+      cursorPosition: cursorPosition ?? null,
+      timestamp: Date.now(),
+    });
+
+    if (this.recentFiles.length > 100) {
+      this.recentFiles.pop();
+    }
+
+    this.persistRecentFiles();
+  }
+
+  findRecentFileByURL(urlString: string) {
+    const existingIndex = this.findRecentFileIndexByURL(urlString);
+    return existingIndex > -1 ? this.recentFiles[existingIndex] : undefined;
+  }
+
+  findRecentFileByRealmURL(url: string) {
+    return this.recentFiles.find((recentFile) => {
+      const realmUrl = new RealmPaths(new URL(url)).url;
+      return realmUrl === recentFile.realmURL.href;
+    });
+  }
+
+  updateCursorPositionByURL(
+    urlString: string,
+    cursorPosition?: CursorPosition,
+  ) {
+    const existingIndex = this.findRecentFileIndexByURL(urlString);
+    if (existingIndex > -1) {
+      this.recentFiles[existingIndex].cursorPosition = cursorPosition ?? null;
+      this.recentFiles[existingIndex].timestamp = Date.now();
+      this.persistRecentFiles();
+    }
+  }
+
+  private persistRecentFiles() {
+    window.localStorage.setItem(
+      RecentFiles,
+      JSON.stringify(
+        this.recentFiles.map((recentFile) => [
+          recentFile.realmURL.toString(),
+          recentFile.filePath,
+          recentFile.cursorPosition,
+          recentFile.timestamp,
+        ]),
+      ),
+    );
+  }
+
+  private findRecentFileIndex(path: LocalPath) {
+    // TODO this wont work when visiting files that come from multiple realms in
+    // code mode...
+    let currentRealmUrl = this.operatorModeStateService.realmURL;
+
+    return this.recentFiles.findIndex(
+      ({ realmURL, filePath }) =>
+        realmURL.href === currentRealmUrl && filePath === path,
+    );
+  }
+
+  private findRecentFileIndexByURL(urlString: string) {
+    return this.recentFiles.findIndex(
+      ({ realmURL, filePath }) => `${realmURL}${filePath}` === urlString,
+    );
+  }
+
+  private extractRecentFilesFromStorage() {
+    let recentFilesString = window.localStorage.getItem(RecentFiles);
+
+    if (recentFilesString) {
+      try {
+        this.recentFiles = new TrackedArray(
+          JSON.parse(recentFilesString).reduce(function (
+            recentFiles: RecentFile[],
+            [realmUrl, filePath, cursorPosition, timestamp]: SerialRecentFile,
+          ) {
+            try {
+              let url = new URL(realmUrl);
+              recentFiles.push({
+                realmURL: url,
+                filePath,
+                cursorPosition,
+                timestamp,
+              });
+            } catch (e) {
+              console.log(
+                `Ignoring non-URL recent file from storage: ${realmUrl}`,
+              );
+            }
+            return recentFiles;
+          }, []),
+        );
+      } catch (e) {
+        console.log('Error restoring recent files', e);
+      }
+    }
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'recent-files-service': RecentFilesService;
+  }
+}

package/bundled-types/host-app/services/render-error-state.ts

@@ -0,0 +1,55 @@
+import type Owner from '@ember/owner';
+import Service from '@ember/service';
+import { service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+import type ResetService from './reset';
+
+// Render route errors abort the parent transition, so the nested render.error
+// route may not receive params or run its model hook. This service preserves
+// the serialized error payload so the template can still display it.
+interface RenderErrorContext {
+  reason: string;
+  cardId?: string;
+  nonce?: string;
+}
+
+export default class RenderErrorStateService extends Service {
+  @service declare reset: ResetService;
+  @tracked private _context: RenderErrorContext | undefined;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.clear();
+  }
+
+  setError(context: RenderErrorContext) {
+    this._context = context;
+  }
+
+  get reason(): string | undefined {
+    return this._context?.reason;
+  }
+
+  get cardId(): string | undefined {
+    return this._context?.cardId;
+  }
+
+  get nonce(): string | undefined {
+    return this._context?.nonce;
+  }
+
+  clear() {
+    this._context = undefined;
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'render-error-state': RenderErrorStateService;
+  }
+}