@thatopen/services 0.23.0 → 0.25.0

package/dist/cli.js

@@ -6797,6 +6797,15 @@ Object.assign(lookup, {
 });
 const DOCUMENT_SCHEMA = "thatopen/document@1";
 const DOCUMENT_FILE = "document.json";
+const SELF_VIEWING_FORMATS = [
+  "pdf",
+  "txt",
+  "md",
+  "json",
+  "csv",
+  "tsv",
+  "frag"
+];
 const versionTag$1 = () => `v-${Date.now()}`;
 function idOf$1(item) {
   return String(item._id ?? item.id ?? "");
@@ -6806,6 +6815,73 @@ class ProjectDocuments {
     this.client = client;
     this.projectId = projectId;
   }
+  /**
+   * Every document of the project: the folders that carry a descriptor.
+   * Plain folders and loose files simply do not appear. One folder listing
+   * for the project plus one file listing and one descriptor download per
+   * folder, fetched in parallel — the storage offers nothing cheaper yet.
+   */
+  async list() {
+    const folders = await this.client.listFolders({
+      projectId: this.projectId
+    });
+    const found = await Promise.all(
+      folders.map(async (folder) => {
+        const folderId = idOf$1(folder);
+        const descriptor = await this.descriptor(folderId);
+        return descriptor ? { folderId, descriptor } : null;
+      })
+    );
+    return found.filter((d) => d !== null);
+  }
+  /**
+   * Converts a loose file into a document: creates the document folder next
+   * to the file, moves the file inside (moving preserves its id), and writes
+   * the descriptor with the file as `native` — and as `views[0]` too when its
+   * format views itself ({@link SELF_VIEWING_FORMATS}; override per call with
+   * `selfView`).
+   *
+   * A file that carries a processed derivative (the old `derivedFileId` link
+   * in its version metadata — an IFC's frag, a LAS's potree) brings it along:
+   * the derivative moves into the same folder and becomes a view, so the
+   * document is born ready to visualize and the link concept retires.
+   */
+  async fromFile(fileId, options) {
+    const item = await this.client.getFile(fileId);
+    const fileName = String(item.name ?? "");
+    const format2 = formatOf(fileName, item.fileExtension);
+    const name = options?.name ?? fileName.replace(/\.[^.]+$/, "") ?? fileName;
+    const folder = await this.client.createFolder(
+      name,
+      item.folderId ? String(item.folderId) : void 0,
+      this.projectId
+    );
+    const folderId = idOf$1(folder);
+    await this.client.updateFile(fileId, { parentFolderId: folderId });
+    const views = [];
+    const derivedId = await this.#derivedFileId(item);
+    if (derivedId) {
+      try {
+        const derived = await this.client.getFile(derivedId);
+        await this.client.updateFile(derivedId, { parentFolderId: folderId });
+        views.push({
+          fileId: derivedId,
+          format: formatOf(String(derived.name ?? ""), derived.fileExtension)
+        });
+      } catch {
+      }
+    }
+    const selfViews = options?.selfView ?? SELF_VIEWING_FORMATS.includes(format2);
+    if (selfViews) views.push({ fileId, format: format2 });
+    const descriptor = {
+      schema: DOCUMENT_SCHEMA,
+      name,
+      native: { fileId, format: format2 },
+      views
+    };
+    await this.setDescriptor(folderId, descriptor);
+    return { folderId, descriptor };
+  }
   /**
    * The document's descriptor, read and validated, or null when the folder
    * has none yet (an old folder, or a plain folder that is not a document).
@@ -6884,6 +6960,28 @@ class ProjectDocuments {
       projectId: this.projectId
     });
   }
+  /**
+   * The legacy `derivedFileId` link, read from the newest version metadata
+   * that carries one. Only `fromFile` looks at it, to migrate the link into
+   * the folder-document shape; nothing writes it any more.
+   */
+  async #derivedFileId(item) {
+    const versions = [...item.versions ?? []].sort(
+      (a, b) => String(b.createdAt ?? "").localeCompare(String(a.createdAt ?? ""))
+    );
+    for (const version2 of versions) {
+      try {
+        const metadata2 = await this.client.getFileVersionMetadata(
+          idOf$1(item),
+          version2.tag
+        );
+        const derived = metadata2?.derivedFileId;
+        if (typeof derived === "string" && derived) return derived;
+      } catch {
+      }
+    }
+    return void 0;
+  }
   async #descriptorFile(folderId) {
     const items2 = await this.client.listFiles({ folderId });
     const found = items2.find(
@@ -6892,6 +6990,12 @@ class ProjectDocuments {
     return found ? { id: idOf$1(found) } : void 0;
   }
 }
+function formatOf(fileName, extension) {
+  const fromExt = (extension ?? "").replace(/^\./, "").toLowerCase();
+  if (fromExt) return fromExt;
+  const dot = fileName.lastIndexOf(".");
+  return dot > 0 ? fileName.slice(dot + 1).toLowerCase() : "";
+}
 function normalize$1(parsed) {
   if (!parsed || typeof parsed !== "object") return null;
   const raw = parsed;