@jxsuite/studio 0.37.1 → 1.1.0

package/src/grid/sources/csv-file-source.ts

@@ -0,0 +1,247 @@
+/**
+ * CSV file grid source — one `.csv` project file edited as a grid.
+ *
+ * The file loads once into a positional string matrix (csv-codec). Columns are typed by the
+ * matching content-type schema when the CSV backs a collection (same resolver as the head panel),
+ * otherwise inferred by sampling values. Commit is atomic whole-file: pending edits are applied to
+ * the matrix, the document is re-serialized, and a save-time staleness check (file text vs. the
+ * load-time text) aborts the entire commit rather than clobber an external change. Only edited
+ * cells are canonicalized — untouched cells keep their raw file text.
+ */
+import { getPlatform } from "../../platform";
+import { projectState } from "../../store";
+import { findContentTypeSchema } from "../../utils/studio-utils";
+import { isRecentLocal, markLocalMutation } from "../../files/fs-events";
+import { parseCsv, serializeCsv } from "../csv-codec";
+import {
+  cellToText,
+  coerceCellInput,
+  columnsFromSchema,
+  inferColumnsFromRows,
+} from "../schema-columns";
+import type { CsvDocument } from "../csv-codec";
+import type {
+  CommitResult,
+  GridCellValue,
+  GridColumn,
+  GridEditBatch,
+  GridRow,
+  GridRowsResult,
+  GridSource,
+} from "../grid-source";
+
+/** Candidate identity columns, in the parser extension's fallback order. */
+const ID_FIELDS = ["id", "sku", "slug", "Slug"];
+
+interface CsvModel {
+  doc: CsvDocument;
+  /** Unique field name per column position (duplicate/empty headers get positional names). */
+  fields: string[];
+  columns: GridColumn[];
+  /** Map of rowKey → matrix row index. */
+  keyToIndex: Map<string, number>;
+  /** Matrix row index → rowKey. */
+  keys: string[];
+  /** File text at load time — the whole-file staleness fingerprint. */
+  loadText: string;
+}
+
+/** Unique grid field names for CSV headers (duplicates/empties fall back to positional names). */
+export function fieldNamesForHeaders(headers: string[]): string[] {
+  const used = new Set<string>();
+  return headers.map((header, i) => {
+    let name = header.trim() === "" ? `column${i + 1}` : header;
+    if (used.has(name)) {
+      name = `${name}__${i + 1}`;
+    }
+    used.add(name);
+    return name;
+  });
+}
+
+/** Pick the identity column: first id-chain field whose values are all unique and non-empty. */
+function pickIdField(fields: string[], doc: CsvDocument): string | null {
+  for (const candidate of ID_FIELDS) {
+    const idx = fields.indexOf(candidate);
+    if (idx === -1) {
+      continue;
+    }
+    const values = doc.rows.map((row) => row[idx] ?? "");
+    if (values.every((v) => v !== "") && new Set(values).size === values.length) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function buildModel(text: string, path: string): CsvModel {
+  const doc = parseCsv(text);
+  const fields = fieldNamesForHeaders(doc.headers);
+  const idField = pickIdField(fields, doc);
+  const idIndex = idField ? fields.indexOf(idField) : -1;
+  const keys = doc.rows.map((row, i) => (idIndex === -1 ? String(i) : row[idIndex]!));
+  const keyToIndex = new Map(keys.map((key, i) => [key, i]));
+
+  // Typed columns when this CSV is a collection source; sniffed kinds otherwise.
+  const contentType = findContentTypeSchema(path, projectState?.projectConfig);
+  const schemaProps = contentType?.schema?.properties ?? {};
+  const sampleRows = doc.rows.slice(0, 50).map((row) => {
+    const cells: Record<string, GridCellValue> = {};
+    for (const [i, field] of fields.entries()) {
+      cells[field] = row[i] ?? "";
+    }
+    return cells;
+  });
+  const inferred = new Map(inferColumnsFromRows(sampleRows).map((c) => [c.field, c]));
+  const typed = new Map(
+    columnsFromSchema(contentType?.schema, { idField: idField ?? undefined }).map((c) => [
+      c.field,
+      c,
+    ]),
+  );
+
+  const columns = fields.map((field, i): GridColumn => {
+    const fromSchema = field in schemaProps ? typed.get(field) : undefined;
+    const column = fromSchema ??
+      inferred.get(field) ?? {
+        editable: true,
+        field,
+        kind: "string" as const,
+        title: doc.headers[i] || field,
+      };
+    return { ...column, pk: field === idField, title: doc.headers[i]?.trim() || column.title };
+  });
+
+  return { columns, doc, fields, keys, keyToIndex, loadText: text };
+}
+
+/** Typed cell values for one matrix row. */
+function rowCells(model: CsvModel, rowIndex: number): Record<string, GridCellValue> {
+  const cells: Record<string, GridCellValue> = {};
+  const row = model.doc.rows[rowIndex] ?? [];
+  for (const [i, field] of model.fields.entries()) {
+    const column = model.columns[i]!;
+    const raw = row[i] ?? "";
+    cells[field] =
+      column.kind === "string" || column.kind === "text" || column.kind === "readonly"
+        ? raw
+        : coerceCellInput(raw, column);
+  }
+  return cells;
+}
+
+/** Apply a batch to a copy of the matrix (cells, then inserts, then deletes). */
+function applyBatch(model: CsvModel, batch: GridEditBatch): CsvDocument {
+  const rows = model.doc.rows.map((row) => [...row]);
+  const colFor = (field: string) => model.fields.indexOf(field);
+
+  for (const cell of batch.cells) {
+    const rowIndex = model.keyToIndex.get(cell.rowKey);
+    const colIndex = colFor(cell.field);
+    if (rowIndex === undefined || colIndex === -1) {
+      continue;
+    }
+    rows[rowIndex]![colIndex] = cellToText(cell.value);
+  }
+  for (const insert of batch.inserts) {
+    const row = model.fields.map((field) => cellToText(insert.cells[field] ?? null));
+    rows.push(row);
+  }
+  const dropIndexes = batch.deletes
+    .map((del) => model.keyToIndex.get(del.rowKey))
+    .filter((i): i is number => i !== undefined)
+    .toSorted((a, b) => b - a);
+  for (const index of dropIndexes) {
+    rows.splice(index, 1);
+  }
+  return { ...model.doc, rows };
+}
+
+/** All batch items resolved with one shared outcome (whole-file commits are atomic). */
+function uniformResult(
+  batch: GridEditBatch,
+  outcome: { ok: boolean; error?: string; stale?: boolean },
+): CommitResult {
+  return {
+    cells: batch.cells.map((c) => ({ field: c.field, rowKey: c.rowKey, ...outcome })),
+    deletes: batch.deletes.map((d) => ({ rowKey: d.rowKey, ...outcome })),
+    inserts: batch.inserts.map((i) => ({
+      error: outcome.error,
+      ok: outcome.ok,
+      tempKey: i.tempKey,
+    })),
+  };
+}
+
+/** Create the grid source for one CSV file. The tab id is the file path. */
+export function createCsvFileSource(path: string): GridSource {
+  let loadPromise: Promise<CsvModel> | null = null;
+
+  const load = (force = false): Promise<CsvModel> => {
+    if (!force && loadPromise) {
+      return loadPromise;
+    }
+    loadPromise = getPlatform()
+      .readFile(path)
+      .then((text) => buildModel(text, path));
+    return loadPromise;
+  };
+
+  return {
+    backingPaths: () => new Map([[path, "*"]]),
+    capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
+
+    async columns(): Promise<GridColumn[]> {
+      const current = await load();
+      return current.columns;
+    },
+
+    async commit(batch: GridEditBatch): Promise<CommitResult> {
+      const current = await load();
+      const platform = getPlatform();
+
+      // Whole-file staleness: abort if the file changed under us (and it wasn't our own write).
+      let onDisk: string | null = null;
+      try {
+        onDisk = await platform.readFile(path);
+      } catch {
+        onDisk = null; // Deleted underneath — treat as stale.
+      }
+      if (onDisk !== current.loadText && !isRecentLocal(path)) {
+        return uniformResult(batch, {
+          error: "File changed on disk — refresh to reload",
+          ok: false,
+          stale: true,
+        });
+      }
+
+      const nextDoc = applyBatch(current, batch);
+      const text = serializeCsv(nextDoc);
+      markLocalMutation(path);
+      await platform.writeFile(path, text);
+      loadPromise = Promise.resolve(buildModel(text, path));
+      return uniformResult(batch, { ok: true });
+    },
+
+    id: path,
+    label: path.split("/").pop() ?? path,
+
+    async refresh(): Promise<void> {
+      await load(true);
+    },
+
+    async rows(): Promise<GridRowsResult> {
+      const current = await load();
+      const rows: GridRow[] = current.doc.rows.map((_, i) => ({
+        cells: rowCells(current, i),
+        key: current.keys[i]!,
+      }));
+      return { rows, total: rows.length };
+    },
+
+    async serializeForSource(batch: GridEditBatch): Promise<string> {
+      const current = await load();
+      return serializeCsv(applyBatch(current, batch));
+    },
+  };
+}

package/src/grid/tabulator-tables.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Minimal ambient types for tabulator-tables 6.x — the package ships no declarations. Only the
+ * surface grid-view.ts touches is typed; extend here as usage grows.
+ */
+declare module "tabulator-tables" {
+  export interface CellComponent {
+    getValue: () => unknown;
+    getField: () => string;
+    getElement: () => HTMLElement;
+    getRow: () => RowComponent;
+    setValue: (value: unknown, mutate?: boolean) => void;
+  }
+
+  export interface RowComponent {
+    getData: () => Record<string, unknown>;
+    getElement: () => HTMLElement;
+    getCells: () => CellComponent[];
+    reformat: () => void;
+  }
+
+  export interface RangeComponent {
+    getRows: () => RowComponent[];
+    getCells: () => CellComponent[][];
+  }
+
+  export interface ColumnComponent {
+    getField: () => string;
+    getWidth: () => number;
+  }
+
+  export type CellEditor = (
+    cell: CellComponent,
+    onRendered: (fn: () => void) => void,
+    success: (value: unknown) => void,
+    cancel: () => void,
+  ) => HTMLElement | false;
+
+  export type CellFormatter = (
+    cell: CellComponent,
+    formatterParams: Record<string, unknown>,
+    onRendered: (fn: () => void) => void,
+  ) => HTMLElement | string;
+
+  export interface ColumnDefinition {
+    title: string;
+    field?: string | undefined;
+    width?: number | undefined;
+    frozen?: boolean | undefined;
+    editor?: CellEditor | undefined;
+    editable?: boolean | ((cell: CellComponent) => boolean) | undefined;
+    formatter?: CellFormatter | undefined;
+    sorter?: string | ((a: unknown, b: unknown) => number) | undefined;
+    headerSort?: boolean | undefined;
+    headerFilter?: string | undefined;
+    cssClass?: string | undefined;
+    resizable?: boolean | string | undefined;
+    headerSortTristate?: boolean | undefined;
+  }
+
+  export interface Options {
+    data?: Record<string, unknown>[];
+    columns?: ColumnDefinition[];
+    index?: string;
+    layout?: string;
+    height?: string | number;
+    renderVertical?: string;
+    renderHorizontal?: string;
+    history?: boolean;
+    reactiveData?: boolean;
+    editTriggerEvent?: string;
+    headerSortClickElement?: string;
+    selectableRange?: number | boolean;
+    selectableRangeColumns?: boolean;
+    selectableRangeRows?: boolean;
+    selectableRangeClearCells?: boolean;
+    selectableRangeClearCellsValue?: unknown;
+    clipboard?: boolean;
+    clipboardCopyStyled?: boolean;
+    clipboardCopyConfig?: Record<string, unknown>;
+    clipboardCopyRowRange?: string;
+    clipboardPasteParser?: string;
+    clipboardPasteAction?: string;
+    movableColumns?: boolean;
+    columnDefaults?: Partial<ColumnDefinition>;
+    rowFormatter?: (row: RowComponent) => void;
+    placeholder?: string;
+  }
+
+  export class Tabulator {
+    constructor(host: HTMLElement, options: Options);
+    static registerModule(modules: unknown[]): void;
+    on(event: string, callback: (...args: never[]) => void): void;
+    replaceData(data: Record<string, unknown>[]): Promise<void>;
+    getRows(activeOnly?: string): RowComponent[];
+    getRanges(): RangeComponent[];
+    setFilter(filter: (data: Record<string, unknown>) => boolean): void;
+    clearFilter(includeHeaderFilters?: boolean): void;
+    redraw(force?: boolean): void;
+    destroy(): void;
+  }
+
+  export const EditModule: unknown;
+  export const FormatModule: unknown;
+  export const SortModule: unknown;
+  export const FilterModule: unknown;
+  export const ResizeColumnsModule: unknown;
+  export const MoveColumnsModule: unknown;
+  export const FrozenColumnsModule: unknown;
+  export const SelectRangeModule: unknown;
+  export const ClipboardModule: unknown;
+  export const ExportModule: unknown;
+  export const KeybindingsModule: unknown;
+  export const InteractionModule: unknown;
+  export const TooltipModule: unknown;
+}
+
+declare module "tabulator-tables/dist/css/tabulator.min.css" {
+  const css: unknown;
+  export default css;
+}

package/src/new-project/add-repo-modal.ts

@@ -0,0 +1,183 @@
+/// <reference lib="dom" />
+/**
+ * Add Existing Repository modal — a filterable picker over `platform.listRepos` (every repo the
+ * platform's account link can reach, personal and organization). Choosing a repo runs
+ * `platform.importProject`, which adopts it as a Jx project (probes project.json, tags + catalogues
+ * it) and resolves with the catalogue root key; the caller opens it through the same path as a
+ * recent project. Repos without a project.json fail with the backend's structured message, shown
+ * inline.
+ */
+
+import { html, nothing } from "lit-html";
+import { errorMessage } from "@jxsuite/schema/parse";
+import { getPlatform } from "../platform";
+import { openModal } from "../ui/layers";
+import type { RepoInfo } from "../types";
+
+let _handle: ReturnType<typeof openModal> | null = null;
+let _repos: RepoInfo[] | null = null;
+let _filter = "";
+let _error = "";
+/** FullName of the repo currently importing ("" = idle). */
+let _importing = "";
+let _resolve: ((result: { root: string } | null) => void) | null = null;
+
+/** True when the active platform can browse + adopt existing repositories. */
+export function platformSupportsAddRepo(): boolean {
+  const platform = getPlatform();
+  return typeof platform.listRepos === "function" && typeof platform.importProject === "function";
+}
+
+/** Open the picker. Resolves with the imported project's catalogue root key, or null when cancelled. */
+export function openAddRepoModal(): Promise<{ root: string } | null> {
+  if (_handle) {
+    return Promise.resolve(null);
+  }
+  _repos = null;
+  _filter = "";
+  _error = "";
+  _importing = "";
+
+  void getPlatform()
+    .listRepos?.()
+    .then((repos) => {
+      _repos = repos;
+    })
+    .catch((error: unknown) => {
+      _repos = [];
+      _error = errorMessage(error);
+    })
+    .finally(() => {
+      renderModal();
+    });
+
+  return new Promise((resolve) => {
+    _resolve = resolve;
+    renderModal();
+  });
+}
+
+export function closeAddRepoModal() {
+  if (!_handle || _importing) {
+    return;
+  }
+  _handle.close();
+  _handle = null;
+  if (_resolve) {
+    _resolve(null);
+    _resolve = null;
+  }
+}
+
+function finish(result: { root: string }) {
+  _importing = "";
+  if (_handle) {
+    _handle.close();
+    _handle = null;
+  }
+  if (_resolve) {
+    _resolve(result);
+    _resolve = null;
+  }
+}
+
+async function chooseRepo(repo: RepoInfo) {
+  if (_importing) {
+    return;
+  }
+  _importing = repo.fullName;
+  _error = "";
+  renderModal();
+  try {
+    const imported = await getPlatform().importProject?.({ name: repo.name, owner: repo.owner });
+    if (imported) {
+      finish(imported);
+      return;
+    }
+    _error = "This platform cannot import repositories.";
+  } catch (error) {
+    _error = errorMessage(error);
+  }
+  _importing = "";
+  renderModal();
+}
+
+function visibleRepos(): RepoInfo[] {
+  const query = _filter.trim().toLowerCase();
+  const repos = _repos ?? [];
+  return query ? repos.filter((r) => r.fullName.toLowerCase().includes(query)) : repos;
+}
+
+function repoRowTpl(repo: RepoInfo) {
+  return html`
+    <button
+      class="add-repo-row"
+      ?disabled=${Boolean(_importing)}
+      title=${repo.fullName}
+      @click=${() => void chooseRepo(repo)}
+    >
+      <span class="add-repo-name">${repo.fullName}</span>
+      <span class="add-repo-meta">
+        ${repo.isJxProject ? html`<span class="add-repo-badge">Jx</span>` : nothing}
+        ${repo.private ? html`<span class="add-repo-badge">private</span>` : nothing}
+        <span>${repo.defaultBranch} · ${repo.permission}</span>
+      </span>
+      ${_importing === repo.fullName
+        ? html`<span class="add-repo-busy">Importing…</span>`
+        : nothing}
+    </button>
+  `;
+}
+
+function bodyTpl() {
+  if (_repos === null) {
+    return html`<div class="add-repo-empty">Loading repositories…</div>`;
+  }
+  const repos = visibleRepos();
+  if (repos.length === 0) {
+    return html`<div class="add-repo-empty">
+      ${_filter
+        ? "No repositories match the filter."
+        : "No repositories are reachable. Install the GitHub App (or widen its repository access) and try again."}
+    </div>`;
+  }
+  return html`<div class="add-repo-list">${repos.map((repo) => repoRowTpl(repo))}</div>`;
+}
+
+function renderModal() {
+  const tpl = html`
+    <sp-underlay open @close=${closeAddRepoModal}></sp-underlay>
+    <div
+      class="new-project-modal add-repo-modal"
+      @keydown=${(e: KeyboardEvent) => {
+        if (e.key === "Escape") {
+          closeAddRepoModal();
+        }
+      }}
+    >
+      <div class="new-project-modal-header">
+        <h2 class="new-project-modal-title">Add existing repository</h2>
+        <sp-action-button quiet size="s" @click=${closeAddRepoModal} title="Close">
+          <sp-icon-close slot="icon"></sp-icon-close>
+        </sp-action-button>
+      </div>
+      <div class="new-project-modal-body">
+        <sp-textfield
+          class="add-repo-filter"
+          placeholder="Filter repositories…"
+          value=${_filter}
+          @input=${(e: Event) => {
+            _filter = (e.target as HTMLInputElement).value;
+            renderModal();
+          }}
+        ></sp-textfield>
+        ${bodyTpl()} ${_error ? html`<div class="new-project-error">${_error}</div>` : nothing}
+      </div>
+    </div>
+  `;
+  if (_handle) {
+    _handle.update(tpl);
+  } else {
+    _handle = openModal(tpl);
+  }
+}

package/src/new-project/new-project-modal.ts

@@ -13,6 +13,7 @@ import { html } from "lit-html";
 import { errorMessage } from "@jxsuite/schema/parse";
 import { openModal } from "../ui/layers";
 import { getPlatform } from "../platform";
+import { installUrlOf } from "../platform-errors";
 import { hasOpenAiKey } from "../services/ai-settings";
 import { setPendingAgentPrompt } from "../services/agent-seed";
 import { createAiCredentialsForm } from "../ui/ai-credentials-form";
@@ -57,6 +58,14 @@ let _paramsSeededFor = "";
 
 let _error = "";
 
+/** GitHub-App install link carried by a structured needs_installation_access failure. */
+let _errorInstallUrl = "";
+
+function captureError(error: unknown) {
+  _error = errorMessage(error);
+  _errorInstallUrl = installUrlOf(error) ?? "";
+}
+
 let _creating = false;
 
 /** Starter templates offered in the picker (empty until loaded / on platforms without starters). */
@@ -111,6 +120,7 @@ export function openNewProjectModal(): Promise<{
   _agentPrompt = "";
   _paramsSeededFor = "";
   _error = "";
+  _errorInstallUrl = "";
   _creating = false;
   _starters = [];
   _dirDerived = true;
@@ -320,7 +330,7 @@ function renderModal() {
       finish(result);
     } catch (error) {
       _creating = false;
-      _error = errorMessage(error);
+      captureError(error);
       renderModal();
     }
   };
@@ -351,7 +361,7 @@ function renderModal() {
       finish(result);
     } catch (error) {
       _creating = false;
-      _error = errorMessage(error);
+      captureError(error);
       renderModal();
     }
   };
@@ -593,7 +603,16 @@ function renderModal() {
         : ""}
       <div class="new-project-modal-body">
         ${bodyTpl()}
-        ${_tab !== "import" && _error ? html`<div class="new-project-error">${_error}</div>` : ""}
+        ${_tab !== "import" && _error
+          ? html`<div class="new-project-error">
+              ${_error}
+              ${_errorInstallUrl
+                ? html`<a href=${_errorInstallUrl} target="_blank" rel="noreferrer">
+                    Install the Jx Suite GitHub App →
+                  </a>`
+                : ""}
+            </div>`
+          : ""}
       </div>
       <div class="new-project-modal-footer">${footerTpl()}</div>
     </div>

package/src/page-params.ts

@@ -11,6 +11,7 @@
  */
 
 import { getPlatform } from "./platform";
+import { loadExtensions } from "./format/format-host";
 import type { JxMutableNode, JxPathsDef } from "@jxsuite/schema/types";
 
 /** Param name → candidate values, in `$paths` declaration order. */
@@ -135,10 +136,15 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
     return out;
   }
 
-  // Content type-based: { contentType: "blog", param: "slug", field: "id" } — resolved through the
-  // Backend's ContentCollection pipeline (the same one the canvas's ContentEntry uses), so every
-  // Offered value is guaranteed to resolve in preview.
-  if ("contentType" in pathsDef && pathsDef.contentType) {
+  // Content type-based: { contentType: "blog", param: "slug", field: "id" } — an open extension
+  // Discriminator member on JxPathsDef, so narrow to string. Resolved through the backend's
+  // ContentCollection pipeline (the same one the canvas's ContentEntry uses), so every offered
+  // Value is guaranteed to resolve in preview.
+  if (
+    "contentType" in pathsDef &&
+    typeof pathsDef.contentType === "string" &&
+    pathsDef.contentType
+  ) {
     const param = pathsDef.param ?? "slug";
     const field = pathsDef.field ?? "id";
     const entries = (await resolveContentCollection(pathsDef.contentType)) as {
@@ -165,8 +171,9 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
     return out;
   }
 
-  // Data file ref: { "$ref": "./data/products.json", param: "id", field: "sku" }
-  if ("$ref" in pathsDef && pathsDef.$ref) {
+  // Data file ref: { "$ref": "./data/products.json", param: "id", field: "sku" } — `$ref` also
+  // Reaches here as an open discriminator key, so narrow to a non-empty string.
+  if ("$ref" in pathsDef && typeof pathsDef.$ref === "string" && pathsDef.$ref) {
     const param = pathsDef.param ?? "id";
     const field = pathsDef.field ?? "id";
     const content = await getPlatform().readFile(pathsDef.$ref.replace(/^\.\//, ""));
@@ -184,6 +191,25 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
   return {};
 }
 
+/**
+ * The `$src` of the ContentCollection class from the enabled extensions payload — whichever
+ * extension's manifest declares a class named `ContentCollection` (its backend-resolved descriptor
+ * path feeds `/__jx_resolve__` directly). Platforms without an extensions payload fall back to the
+ * historical parser-package specifier.
+ *
+ * @returns {Promise<string>}
+ */
+async function contentCollectionSrc(): Promise<string> {
+  const extensions = await loadExtensions();
+  for (const ext of extensions) {
+    const cls = ext.classes?.find((c) => c.name === "ContentCollection");
+    if (cls) {
+      return cls.path;
+    }
+  }
+  return "@jxsuite/parser/ContentCollection.class.json";
+}
+
 /**
  * Resolve a ContentCollection for a content type via the PAL, falling back to a plain dev-proxy
  * fetch on platforms that predate `resolveClass`.
@@ -191,10 +217,10 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
  * @param {string} contentType
  * @returns {Promise<unknown>}
  */
-function resolveContentCollection(contentType: string) {
+async function resolveContentCollection(contentType: string) {
   const body = {
     $prototype: "ContentCollection",
-    $src: "@jxsuite/parser/ContentCollection.class.json",
+    $src: await contentCollectionSrc(),
     contentType,
   };
   const platform = getPlatform();