Initial

resources/app/client/data/documents/folder.js

@@ -0,0 +1,354 @@
+/**
+ * The client-side Folder document which extends the common BaseFolder model.
+ * @extends foundry.documents.BaseFolder
+ * @mixes ClientDocumentMixin
+ *
+ * @see {@link Folders}                     The world-level collection of Folder documents
+ * @see {@link FolderConfig}                The Folder configuration application
+ */
+class Folder extends ClientDocumentMixin(foundry.documents.BaseFolder) {
+
+  /**
+   * The depth of this folder in its sidebar tree
+   * @type {number}
+   */
+  depth;
+
+  /**
+   * An array of other Folders which are the displayed children of this one. This differs from the results of
+   * {@link Folder.getSubfolders} because reports the subset of child folders which  are displayed to the current User
+   * in the UI.
+   * @type {Folder[]}
+   */
+  children;
+
+  /**
+   * Return whether the folder is displayed in the sidebar to the current User.
+   * @type {boolean}
+   */
+  displayed = false;
+
+  /* -------------------------------------------- */
+  /*  Properties                                  */
+  /* -------------------------------------------- */
+
+  /**
+   * The array of the Document instances which are contained within this Folder,
+   * unless it's a Folder inside a Compendium pack, in which case it's the array
+   * of objects inside the index of the pack that are contained in this Folder.
+   * @type {(ClientDocument|object)[]}
+   */
+  get contents() {
+    if ( this.#contents ) return this.#contents;
+    if ( this.pack ) return game.packs.get(this.pack).index.filter(d => d.folder === this.id );
+    return this.documentCollection?.filter(d => d.folder === this) ?? [];
+  }
+
+  set contents(value) {
+    this.#contents = value;
+  }
+
+  #contents;
+
+  /* -------------------------------------------- */
+
+  /**
+   * The reference to the Document type which is contained within this Folder.
+   * @type {Function}
+   */
+  get documentClass() {
+    return CONFIG[this.type].documentClass;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * The reference to the WorldCollection instance which provides Documents to this Folder,
+   * unless it's a Folder inside a Compendium pack, in which case it's the index of the pack.
+   * A world Folder containing CompendiumCollections will have neither.
+   * @type {WorldCollection|Collection|undefined}
+   */
+  get documentCollection() {
+    if ( this.pack ) return game.packs.get(this.pack).index;
+    return game.collections.get(this.type);
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Return whether the folder is currently expanded within the sidebar interface.
+   * @type {boolean}
+   */
+  get expanded() {
+    return game.folders._expanded[this.uuid] || false;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Return the list of ancestors of this folder, starting with the parent.
+   * @type {Folder[]}
+   */
+  get ancestors() {
+    if ( !this.folder ) return [];
+    return [this.folder, ...this.folder.ancestors];
+  }
+
+  /* -------------------------------------------- */
+  /*  Methods                                     */
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  async _preCreate(data, options, user) {
+
+    // If the folder would be created past the maximum depth, throw an error
+    if ( data.folder ) {
+      const collection = data.pack ? game.packs.get(data.pack).folders : game.folders;
+      const parent = collection.get(data.folder);
+      if ( !parent ) return;
+      const maxDepth = data.pack ? (CONST.FOLDER_MAX_DEPTH - 1) : CONST.FOLDER_MAX_DEPTH;
+      if ( (parent.ancestors.length + 1) >= maxDepth ) throw new Error(game.i18n.format("FOLDER.ExceededMaxDepth", {depth: maxDepth}));
+    }
+
+    return super._preCreate(data, options, user);
+  }
+
+  /* -------------------------------------------- */
+
+  /** @override */
+  static async createDialog(data={}, options={}) {
+    const folder = new Folder.implementation(foundry.utils.mergeObject({
+      name: Folder.implementation.defaultName({pack: options.pack}),
+      sorting: "a"
+    }, data), { pack: options.pack });
+    return new Promise(resolve => {
+      options.resolve = resolve;
+      new FolderConfig(folder, options).render(true);
+    });
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Export all Documents contained in this Folder to a given Compendium pack.
+   * Optionally update existing Documents within the Pack by name, otherwise append all new entries.
+   * @param {CompendiumCollection} pack       A Compendium pack to which the documents will be exported
+   * @param {object} [options]                Additional options which customize how content is exported.
+   *                                          See {@link ClientDocumentMixin#toCompendium}
+   * @param {boolean} [options.updateByName=false]    Update existing entries in the Compendium pack, matching by name
+   * @param {boolean} [options.keepId=false]          Retain the original _id attribute when updating an entity
+   * @param {boolean} [options.keepFolders=false]     Retain the existing Folder structure
+   * @param {string} [options.folder]                 A target folder id to which the documents will be exported
+   * @returns {Promise<CompendiumCollection>}  The updated Compendium Collection instance
+   */
+  async exportToCompendium(pack, options={}) {
+    const updateByName = options.updateByName ?? false;
+    const index = await pack.getIndex();
+    ui.notifications.info(game.i18n.format("FOLDER.Exporting", {
+      type: game.i18n.localize(getDocumentClass(this.type).metadata.labelPlural),
+      compendium: pack.collection
+    }));
+    options.folder ||= null;
+
+    // Classify creations and updates
+    const foldersToCreate = [];
+    const foldersToUpdate = [];
+    const documentsToCreate = [];
+    const documentsToUpdate = [];
+
+    // Ensure we do not overflow maximum allowed folder depth
+    const originDepth = this.ancestors.length;
+    const targetDepth = options.folder ? ((pack.folders.get(options.folder)?.ancestors.length ?? 0) + 1) : 0;
+
+    /**
+     * Recursively extract the contents and subfolders of a Folder into the Pack
+     * @param {Folder} folder       The Folder to extract
+     * @param {number} [_depth]     An internal recursive depth tracker
+     * @private
+     */
+    const _extractFolder = async (folder, _depth=0) => {
+      const folderData = folder.toCompendium(pack, {...options, clearSort: false, keepId: true});
+
+      if ( options.keepFolders ) {
+        // Ensure that the exported folder is within the maximum allowed folder depth
+        const currentDepth = _depth + targetDepth - originDepth;
+        const exceedsDepth = currentDepth > pack.maxFolderDepth;
+        if ( exceedsDepth ) {
+          throw new Error(`Folder "${folder.name}" exceeds maximum allowed folder depth of ${pack.maxFolderDepth}`);
+        }
+
+        // Re-parent child folders into the target folder or into the compendium root
+        if ( folderData.folder === this.id ) folderData.folder = options.folder;
+
+        // Classify folder data for creation or update
+        if ( folder !== this ) {
+          const existing = updateByName ? pack.folders.find(f => f.name === folder.name) : pack.folders.get(folder.id);
+          if ( existing ) {
+            folderData._id = existing._id;
+            foldersToUpdate.push(folderData);
+          }
+          else foldersToCreate.push(folderData);
+        }
+      }
+
+      // Iterate over Documents in the Folder, preparing each for export
+      for ( let doc of folder.contents ) {
+        const data = doc.toCompendium(pack, options);
+
+        // Re-parent immediate child documents into the target folder.
+        if ( data.folder === this.id ) data.folder = options.folder;
+
+        // Otherwise retain their folder structure if keepFolders is true.
+        else data.folder = options.keepFolders ? folderData._id : options.folder;
+
+        // Generate thumbnails for Scenes
+        if ( doc instanceof Scene ) {
+          const { thumb } = await doc.createThumbnail({ img: data.background.src });
+          data.thumb = thumb;
+        }
+
+        // Classify document data for creation or update
+        const existing = updateByName ? index.find(i => i.name === data.name) : index.find(i => i._id === data._id);
+        if ( existing ) {
+          data._id = existing._id;
+          documentsToUpdate.push(data);
+        }
+        else documentsToCreate.push(data);
+        console.log(`Prepared "${data.name}" for export to "${pack.collection}"`);
+      }
+
+      // Iterate over subfolders of the Folder, preparing each for export
+      for ( let c of folder.children ) await _extractFolder(c.folder, _depth+1);
+    };
+
+    // Prepare folders for export
+    try {
+      await _extractFolder(this, 0);
+    } catch(err) {
+      const msg = `Cannot export Folder "${this.name}" to Compendium pack "${pack.collection}":\n${err.message}`;
+      return ui.notifications.error(msg, {console: true});
+    }
+
+    // Create and update Folders
+    if ( foldersToUpdate.length ) {
+      await this.constructor.updateDocuments(foldersToUpdate, {
+        pack: pack.collection,
+        diff: false,
+        recursive: false,
+        render: false
+      });
+    }
+    if ( foldersToCreate.length ) {
+      await this.constructor.createDocuments(foldersToCreate, {
+        pack: pack.collection,
+        keepId: true,
+        render: false
+      });
+    }
+
+    // Create and update Documents
+    const cls = pack.documentClass;
+    if ( documentsToUpdate.length ) await cls.updateDocuments(documentsToUpdate, {
+      pack: pack.collection,
+      diff: false,
+      recursive: false,
+      render: false
+    });
+    if ( documentsToCreate.length ) await cls.createDocuments(documentsToCreate, {
+      pack: pack.collection,
+      keepId: options.keepId,
+      render: false
+    });
+
+    // Re-render the pack
+    ui.notifications.info(game.i18n.format("FOLDER.ExportDone", {
+      type: game.i18n.localize(getDocumentClass(this.type).metadata.labelPlural), compendium: pack.collection}));
+    pack.render(false);
+    return pack;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Provide a dialog form that allows for exporting the contents of a Folder into an eligible Compendium pack.
+   * @param {string} pack       A pack ID to set as the default choice in the select input
+   * @param {object} options    Additional options passed to the Dialog.prompt method
+   * @returns {Promise<void>}   A Promise which resolves or rejects once the dialog has been submitted or closed
+   */
+  async exportDialog(pack, options={}) {
+
+    // Get eligible pack destinations
+    const packs = game.packs.filter(p => (p.documentName === this.type) && !p.locked);
+    if ( !packs.length ) {
+      return ui.notifications.warn(game.i18n.format("FOLDER.ExportWarningNone", {
+        type: game.i18n.localize(getDocumentClass(this.type).metadata.label)}));
+    }
+
+    // Render the HTML form
+    const html = await renderTemplate("templates/sidebar/apps/folder-export.html", {
+      packs: packs.reduce((obj, p) => {
+        obj[p.collection] = p.title;
+        return obj;
+      }, {}),
+      pack: options.pack ?? null,
+      merge: options.merge ?? true,
+      keepId: options.keepId ?? true,
+      keepFolders: options.keepFolders ?? true,
+      hasFolders: options.pack?.folders?.length ?? false,
+      folders: options.pack?.folders?.map(f => ({id: f.id, name: f.name})) || [],
+    });
+
+    // Display it as a dialog prompt
+    return FolderExport.prompt({
+      title: `${game.i18n.localize("FOLDER.ExportTitle")}: ${this.name}`,
+      content: html,
+      label: game.i18n.localize("FOLDER.ExportTitle"),
+      callback: html => {
+        const form = html[0].querySelector("form");
+        const pack = game.packs.get(form.pack.value);
+        return this.exportToCompendium(pack, {
+          updateByName: form.merge.checked,
+          keepId: form.keepId.checked,
+          keepFolders: form.keepFolders.checked,
+          folder: form.folder.value
+        });
+      },
+      rejectClose: false,
+      options
+    });
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Get the Folder documents which are sub-folders of the current folder, either direct children or recursively.
+   * @param {boolean} [recursive=false] Identify child folders recursively, if false only direct children are returned
+   * @returns {Folder[]}  An array of Folder documents which are subfolders of this one
+   */
+  getSubfolders(recursive=false) {
+    let subfolders = game.folders.filter(f => f._source.folder === this.id);
+    if ( recursive && subfolders.length ) {
+      for ( let f of subfolders ) {
+        const children = f.getSubfolders(true);
+        subfolders = subfolders.concat(children);
+      }
+    }
+    return subfolders;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Get the Folder documents which are parent folders of the current folder or any if its parents.
+   * @returns {Folder[]}    An array of Folder documents which are parent folders of this one
+   */
+  getParentFolders() {
+    let folders = [];
+    let parent = this.folder;
+    while ( parent ) {
+      folders.push(parent);
+      parent = parent.folder;
+    }
+    return folders;
+  }
+}