@nextcloud/files 3.5.1 → 3.6.0

package/dist/index.d.ts

@@ -12,7 +12,8 @@ export { FileType } from './files/fileType';
 export { File, type IFile } from './files/file';
 export { Folder, type IFolder } from './files/folder';
 export { Node, NodeStatus, type INode } from './files/node';
-export { isFilenameValid, getUniqueName } from './utils/filename';
+export * from './utils/filename-validation';
+export { getUniqueName } from './utils/filename';
 export { formatFileSize, parseFileSize } from './utils/fileSize';
 export { orderBy } from './utils/sorting';
 export { sortNodes, FilesSortingMode, type FilesSortingOptions } from './utils/fileSorting';

package/dist/index.mjs

@@ -6,6 +6,7 @@ import { generateRemoteUrl } from "@nextcloud/router";
 import { CancelablePromise } from "cancelable-promise";
 import { createClient, getPatcher } from "webdav";
 import { isPublicShare, getSharingToken } from "@nextcloud/sharing/public";
+import { getCapabilities } from "@nextcloud/capabilities";
 import { getCanonicalLocale, getLanguage } from "@nextcloud/l10n";
 import { TypedEventTarget } from "typescript-event-target";
 const logger = getLoggerBuilder().setApp("@nextcloud/files").detectUser().build();
@@ -428,6 +429,9 @@ const validateData = (data, davService) => {
   if (!data.source.startsWith("http")) {
     throw new Error("Invalid source format, only http(s) is supported");
   }
+  if (data.displayname && typeof data.displayname !== "string") {
+    throw new Error("Invalid displayname type");
+  }
   if (data.mtime && !(data.mtime instanceof Date)) {
     throw new Error("Invalid mtime type");
   }
@@ -504,7 +508,12 @@ class Node {
   };
   constructor(data, davService) {
     validateData(data, davService || this._knownDavService);
-    this._data = { ...data, attributes: {} };
+    this._data = {
+      // TODO: Remove with next major release, this is just for compatibility
+      displayname: data.attributes?.displayname,
+      ...data,
+      attributes: {}
+    };
     this._attributes = new Proxy(this._data.attributes, this.handler);
     this.update(data.attributes ?? {});
     if (davService) {
@@ -534,6 +543,21 @@ class Node {
   get basename() {
     return basename(this.source);
   }
+  /**
+   * The nodes displayname
+   * By default the display name and the `basename` are identical,
+   * but it is possible to have a different name. This happens
+   * on the files app for example for shared folders.
+   */
+  get displayname() {
+    return this._data.displayname || this.basename;
+  }
+  /**
+   * Set the displayname
+   */
+  set displayname(displayname) {
+    this._data.displayname = displayname;
+  }
   /**
    * Get this object's extension
    * There is no setter as the source is not meant to be changed manually.
@@ -696,7 +720,11 @@ class Node {
    */
   move(destination) {
     validateData({ ...this._data, source: destination }, this._knownDavService);
+    const oldBasename = this.basename;
     this._data.source = destination;
+    if (this.displayname === oldBasename && this.basename !== oldBasename) {
+      this.displayname = this.basename;
+    }
     this.updateMtime();
   }
   /**
@@ -841,6 +869,7 @@ const davResultToNode = function(node, filesRoot = davRootPath, remoteURL = davR
     source: `${remoteURL}${node.filename}`,
     mtime: new Date(Date.parse(node.lastmod)),
     mime: node.mime || "application/octet-stream",
+    displayname: props.displayname,
     size: props?.size || Number.parseInt(props.getcontentlength || "0"),
     // The fileid is set to -1 for failed requests
     status: id < 0 ? NodeStatus.FAILED : void 0,
@@ -856,16 +885,81 @@ const davResultToNode = function(node, filesRoot = davRootPath, remoteURL = davR
   delete nodeData.attributes?.props;
   return node.type === "file" ? new File(nodeData) : new Folder(nodeData);
 };
-const forbiddenCharacters = window._oc_config?.forbidden_filenames_characters ?? ["/", "\\"];
-const forbiddenFilenameRegex = window._oc_config?.blacklist_files_regex ? new RegExp(window._oc_config.blacklist_files_regex) : null;
-function isFilenameValid(filename) {
-  if (forbiddenCharacters.some((character) => filename.includes(character))) {
-    return false;
+var InvalidFilenameErrorReason = /* @__PURE__ */ ((InvalidFilenameErrorReason2) => {
+  InvalidFilenameErrorReason2["ReservedName"] = "reserved name";
+  InvalidFilenameErrorReason2["Character"] = "character";
+  InvalidFilenameErrorReason2["Extension"] = "extension";
+  return InvalidFilenameErrorReason2;
+})(InvalidFilenameErrorReason || {});
+class InvalidFilenameError extends Error {
+  constructor(options) {
+    super(`Invalid ${options.reason} '${options.segment}' in filename '${options.filename}'`, { cause: options });
   }
-  if (forbiddenFilenameRegex !== null && filename.match(forbiddenFilenameRegex)) {
-    return false;
+  /**
+   * The filename that was validated
+   */
+  get filename() {
+    return this.cause.filename;
+  }
+  /**
+   * Reason why the validation failed
+   */
+  get reason() {
+    return this.cause.reason;
+  }
+  /**
+   * Part of the filename that caused this error
+   */
+  get segment() {
+    return this.cause.segment;
+  }
+}
+function validateFilename(filename) {
+  const capabilities = getCapabilities().files;
+  const forbiddenCharacters = capabilities.forbidden_filename_characters ?? window._oc_config?.forbidden_filenames_characters ?? ["/", "\\"];
+  for (const character of forbiddenCharacters) {
+    if (filename.includes(character)) {
+      throw new InvalidFilenameError({ segment: character, reason: "character", filename });
+    }
+  }
+  filename = filename.toLocaleLowerCase();
+  const forbiddenFilenames = capabilities.forbidden_filenames ?? [".htaccess"];
+  if (forbiddenFilenames.includes(filename)) {
+    throw new InvalidFilenameError({
+      filename,
+      segment: filename,
+      reason: "reserved name"
+      /* ReservedName */
+    });
+  }
+  const endOfBasename = filename.indexOf(".", 1);
+  const basename2 = filename.substring(0, endOfBasename === -1 ? void 0 : endOfBasename);
+  const forbiddenFilenameBasenames = capabilities.forbidden_filename_basenames ?? [];
+  if (forbiddenFilenameBasenames.includes(basename2)) {
+    throw new InvalidFilenameError({
+      filename,
+      segment: basename2,
+      reason: "reserved name"
+      /* ReservedName */
+    });
+  }
+  const forbiddenFilenameExtensions = capabilities.forbidden_filename_extensions ?? [".part", ".filepart"];
+  for (const extension of forbiddenFilenameExtensions) {
+    if (filename.length > extension.length && filename.endsWith(extension)) {
+      throw new InvalidFilenameError({ segment: extension, reason: "extension", filename });
+    }
+  }
+}
+function isFilenameValid(filename) {
+  try {
+    validateFilename(filename);
+    return true;
+  } catch (error) {
+    if (error instanceof InvalidFilenameError) {
+      return false;
+    }
+    throw error;
   }
-  return true;
 }
 function getUniqueName(name, otherNames, options) {
   const opts = {
@@ -2812,6 +2906,8 @@ export {
   FilesSortingMode,
   Folder,
   Header,
+  InvalidFilenameError,
+  InvalidFilenameErrorReason,
   Navigation,
   NewMenuEntryCategory,
   Node,
@@ -2847,5 +2943,6 @@ export {
   registerFileAction,
   registerFileListHeaders,
   removeNewFileMenuEntry,
-  sortNodes
+  sortNodes,
+  validateFilename
 };