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

package/bundled-types/host-app/config/environment.ts

@@ -0,0 +1,66 @@
+import { assert } from '@ember/debug';
+import loadConfigFromMeta from '@embroider/config-meta-loader';
+
+const config = loadConfigFromMeta('@cardstack/host') as unknown;
+
+assert(
+  'config is not an object',
+  typeof config === 'object' && config !== null,
+);
+assert(
+  'modulePrefix was not detected on your config',
+  'modulePrefix' in config && typeof config.modulePrefix === 'string',
+);
+assert(
+  'locationType was not detected on your config',
+  'locationType' in config && typeof config.locationType === 'string',
+);
+assert(
+  'rootURL was not detected on your config',
+  'rootURL' in config && typeof config.rootURL === 'string',
+);
+assert(
+  'APP was not detected on your config',
+  'APP' in config && typeof config.APP === 'object',
+);
+
+export default config as {
+  environment: string;
+  modulePrefix: string;
+  podModulePrefix: string;
+  locationType: 'history' | 'hash' | 'none' | 'auto';
+  rootURL: string;
+  APP: Record<string, unknown>;
+  matrixURL: string;
+  matrixServerName: string;
+
+  realmServerURL: string;
+  resolvedBaseRealmURL: string;
+  resolvedCatalogRealmURL: string | undefined;
+  resolvedSkillsRealmURL: string;
+  resolvedOpenRouterRealmURL: string | undefined;
+  hostsOwnAssets: boolean;
+  realmsServed?: string[];
+  logLevels: string;
+  iconsURL: string;
+  autoSaveDelayMs: number;
+  monacoDebounceMs: number;
+  monacoCursorDebounceMs: number;
+  serverEchoDebounceMs: number;
+  loginMessageTimeoutMs: number;
+  minSaveTaskDurationMs: number;
+  cardRenderTimeout: number;
+  sqlSchema: string;
+  assetsURL: string;
+  stripePaymentLink: string;
+  featureFlags?: {
+    AI_PATCHING_CORRECTNESS_CHECKS?: boolean;
+  };
+  publishedRealmDomainOverrides: string;
+  publishedRealmBoxelSpaceDomain: string;
+  publishedRealmBoxelSiteDomain: string;
+  defaultSystemCardId?: string;
+  defaultFieldSpecId?: string;
+  cardSizeLimitBytes: number;
+  fileSizeLimitBytes: number;
+} & Record<string, unknown>;

package/bundled-types/host-app/deprecation-workflow.js

@@ -0,0 +1,30 @@
+import setupDeprecationWorkflow from 'ember-cli-deprecation-workflow';
+
+setupDeprecationWorkflow({
+  workflow: [
+    {
+      handler: 'silence',
+      matchId: 'deprecate-import--set-classic-decorator-from-ember',
+    },
+    {
+      handler: 'silence',
+      matchId: 'deprecate-import-view-utils-from-ember',
+    },
+    {
+      handler: 'silence',
+      matchId: 'deprecate-import-env-from-ember',
+    },
+    {
+      handler: 'silence',
+      matchId: 'deprecate-import-onerror-from-ember',
+    },
+    {
+      handler: 'silence',
+      matchId: 'deprecate-import-libraries-from-ember',
+    },
+    {
+      handler: 'silence',
+      matchId: 'importing-inject-from-ember-service',
+    },
+  ],
+});

package/bundled-types/host-app/lib/browser-queue.ts

@@ -0,0 +1,198 @@
+import debounce from 'lodash/debounce';
+
+import {
+  type QueueRunner,
+  type QueuePublisher,
+  type QueuePublishArgs,
+  type QueueResultMapper,
+  type QueueWaiter,
+  type QueueCoalesceCandidate,
+  type PgPrimitive,
+  getQueueJobCoalesceHandler,
+  normalizeQueueJobSpec,
+  identityResultMapper,
+  makeQueueWaiter,
+  Job,
+  Deferred,
+} from '@cardstack/runtime-common';
+
+let id = 0;
+
+interface QueueWorkItem {
+  jobType: string;
+  concurrencyGroup: string | null;
+  timeout: number;
+  priority: number;
+  args: PgPrimitive;
+  id: number;
+  waiters: Set<QueueWaiter>;
+}
+
+export class BrowserQueue implements QueuePublisher, QueueRunner {
+  #isDestroyed = false;
+  #hasStarted = false;
+  #flush: Promise<void> | undefined;
+
+  // no need for "onAfterJob--that's just the Job.done promise
+  constructor(private onBeforeJob?: (jobId: number) => void) {}
+
+  private jobs: QueueWorkItem[] = [];
+  private types: Map<string, (arg: any) => Promise<any>> = new Map();
+
+  get isDestroyed() {
+    return this.#isDestroyed;
+  }
+
+  get hasStarted() {
+    return this.#hasStarted;
+  }
+
+  async flush() {
+    await this.#flush;
+  }
+
+  async start() {
+    this.#hasStarted = true;
+  }
+
+  register<A, T>(category: string, handler: (arg: A) => Promise<T>) {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot register category on a destroyed Queue`);
+    }
+    this.types.set(category, handler);
+    this.debouncedDrainJobs();
+  }
+
+  async publish<TResult = PgPrimitive>({
+    mapResult,
+    ...request
+  }: QueuePublishArgs<TResult>): Promise<Job<TResult>> {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot publish job on a destroyed Queue`);
+    }
+    let incoming = normalizeQueueJobSpec(request);
+    let coalesce = getQueueJobCoalesceHandler(incoming.jobType);
+
+    let workItem: QueueWorkItem;
+    if (!coalesce) {
+      workItem = {
+        ...incoming,
+        id: ++id,
+        waiters: new Set(),
+      };
+      this.jobs.push(workItem);
+    } else {
+      let candidates: QueueCoalesceCandidate[] = this.jobs
+        .filter((job) => job.concurrencyGroup === incoming.concurrencyGroup)
+        .map((job) => ({
+          id: job.id,
+          jobType: job.jobType,
+          concurrencyGroup: job.concurrencyGroup,
+          timeout: job.timeout,
+          priority: job.priority,
+          args: job.args,
+        }));
+      // BrowserQueue runs jobs synchronously after a debounced drain, so
+      // there are no "in-flight" jobs from the publisher's perspective —
+      // every queued workItem is still pending until drainJobs picks it up.
+      let decision = coalesce({
+        incoming,
+        candidates,
+        inFlightCandidates: [],
+      });
+
+      if (decision.type === 'insert') {
+        let jobSpec = decision.job ?? incoming;
+        workItem = {
+          ...jobSpec,
+          id: ++id,
+          waiters: new Set(),
+        };
+        this.jobs.push(workItem);
+      } else {
+        let existingWorkItem = this.jobs.find(
+          (job) => job.id === decision.jobId,
+        );
+        if (!existingWorkItem) {
+          workItem = {
+            ...incoming,
+            id: ++id,
+            waiters: new Set(),
+          };
+          this.jobs.push(workItem);
+        } else {
+          workItem = existingWorkItem;
+        }
+        if (decision.update) {
+          if (decision.update.jobType !== undefined) {
+            workItem.jobType = decision.update.jobType;
+          }
+          if (decision.update.args !== undefined) {
+            workItem.args = decision.update.args;
+          }
+          if (decision.update.priority !== undefined) {
+            workItem.priority = decision.update.priority;
+          }
+          if (decision.update.timeout !== undefined) {
+            workItem.timeout = decision.update.timeout;
+          }
+        }
+      }
+    }
+
+    let deferred = new Deferred<TResult>();
+    workItem.waiters.add(
+      makeQueueWaiter(
+        deferred,
+        mapResult == null
+          ? (identityResultMapper as QueueResultMapper<TResult>)
+          : mapResult,
+      ),
+    );
+    this.debouncedDrainJobs();
+    return new Job(workItem.id, deferred);
+  }
+
+  private debouncedDrainJobs = debounce(() => {
+    this.drainJobs();
+  }, 1);
+
+  private async drainJobs() {
+    await this.flush();
+
+    let jobsDrained: () => void;
+    this.#flush = new Promise((res) => (jobsDrained = res));
+    let jobs = [...this.jobs];
+    this.jobs = [];
+    for (let workItem of jobs) {
+      let { id: jobId, jobType, args } = workItem;
+      let handler = this.types.get(jobType);
+      if (!handler) {
+        // no handler for this job, add it back to the queue
+        this.jobs.push(workItem);
+        continue;
+      }
+
+      if (this.onBeforeJob) {
+        this.onBeforeJob(jobId);
+      }
+      try {
+        let result = await handler(args);
+        for (let waiter of workItem.waiters) {
+          waiter.fulfillFromResult(result as PgPrimitive);
+        }
+      } catch (e: unknown) {
+        for (let waiter of workItem.waiters) {
+          waiter.rejectFromResult(e as PgPrimitive);
+        }
+      }
+    }
+
+    jobsDrained!();
+  }
+
+  async destroy() {
+    this.#isDestroyed = true;
+    await this.flush();
+  }
+}