@nextcloud/files 3.6.0 → 3.7.0

package/dist/index.d.ts

@@ -15,11 +15,10 @@ export { Node, NodeStatus, type INode } from './files/node';
 export * from './utils/filename-validation';
 export { getUniqueName } from './utils/filename';
 export { formatFileSize, parseFileSize } from './utils/fileSize';
-export { orderBy } from './utils/sorting';
+export { orderBy, type SortingOrder } from './utils/sorting';
 export { sortNodes, FilesSortingMode, type FilesSortingOptions } from './utils/fileSorting';
-export * from './navigation/navigation';
-export * from './navigation/column';
-export * from './navigation/view';
+export * from './navigation/index';
+export * from './fileListFilters';
 /**
  * Add a new menu entry to the upload manager menu
  *

package/dist/index.mjs

@@ -869,7 +869,8 @@ 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,
+    // Manually cast to work around for https://github.com/perry-mitchell/webdav-client/pull/380
+    displayname: props.displayname !== void 0 ? String(props.displayname) : void 0,
     size: props?.size || Number.parseInt(props.getcontentlength || "0"),
     // The fileid is set to -1 for failed requests
     status: id < 0 ? NodeStatus.FAILED : void 0,
@@ -1026,10 +1027,10 @@ function stringify(value) {
   }
   return String(value);
 }
-function orderBy(collection, identifiers, orders) {
-  identifiers = identifiers ?? [(value) => value];
+function orderBy(collection, identifiers2, orders) {
+  identifiers2 = identifiers2 ?? [(value) => value];
   orders = orders ?? [];
-  const sorting = identifiers.map((_, index) => (orders[index] ?? "asc") === "asc" ? 1 : -1);
+  const sorting = identifiers2.map((_, index) => (orders[index] ?? "asc") === "asc" ? 1 : -1);
   const collator = Intl.Collator(
     [getLanguage(), getCanonicalLocale()],
     {
@@ -1039,7 +1040,7 @@ function orderBy(collection, identifiers, orders) {
     }
   );
   return [...collection].sort((a, b) => {
-    for (const [index, identifier] of identifiers.entries()) {
+    for (const [index, identifier] of identifiers2.entries()) {
       const value = collator.compare(stringify(identifier(a)), stringify(identifier(b)));
       if (value !== 0) {
         return value * sorting[index];
@@ -1063,14 +1064,14 @@ function sortNodes(nodes, options = {}) {
     ...options
   };
   const basename2 = (name) => name.lastIndexOf(".") > 0 ? name.slice(0, name.lastIndexOf(".")) : name;
-  const identifiers = [
+  const identifiers2 = [
     // 1: Sort favorites first if enabled
     ...sortingOptions.sortFavoritesFirst ? [(v) => v.attributes?.favorite !== 1] : [],
     // 2: Sort folders first if sorting by name
     ...sortingOptions.sortFoldersFirst ? [(v) => v.type !== "folder"] : [],
-    // 3: Use sorting mode if NOT basename (to be able to use displayname too)
+    // 3: Use sorting mode if NOT basename (to be able to use display name too)
     ...sortingOptions.sortingMode !== "basename" ? [(v) => v[sortingOptions.sortingMode]] : [],
-    // 4: Use displayname if available, fallback to name
+    // 4: Use display name if available, fallback to name
     (v) => basename2(v.attributes?.displayname || v.basename),
     // 5: Finally, use basename if all previous sorting methods failed
     (v) => v.basename
@@ -1089,7 +1090,7 @@ function sortNodes(nodes, options = {}) {
     // for 5: use configured sorting direction
     sortingOptions.sortingOrder
   ];
-  return orderBy(nodes, identifiers, orders);
+  return orderBy(nodes, identifiers2, orders);
 }
 class Navigation extends TypedEventTarget {
   _views = [];
@@ -1187,6 +1188,9 @@ const isValidColumn = function(column) {
   }
   return true;
 };
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var validator$2 = {};
 var util$3 = {};
 (function(exports) {
@@ -1380,7 +1384,7 @@ validator$2.validate = function(xmlData, options) {
   } else if (tags.length == 1) {
     return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
   } else if (tags.length > 0) {
-    return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
+    return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t2) => t2.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
   }
   return true;
 };
@@ -1490,15 +1494,15 @@ function validateAttributeString(attrStr, options) {
   return true;
 }
 function validateNumberAmpersand(xmlData, i) {
-  let re = /\d/;
+  let re2 = /\d/;
   if (xmlData[i] === "x") {
     i++;
-    re = /[\da-fA-F]/;
+    re2 = /[\da-fA-F]/;
   }
   for (; i < xmlData.length; i++) {
     if (xmlData[i] === ";")
       return i;
-    if (!xmlData[i].match(re))
+    if (!xmlData[i].match(re2))
       break;
   }
   return -1;
@@ -2880,6 +2884,534 @@ const isValidView = function(view) {
   }
   return true;
 };
+const debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+};
+var debug_1 = debug$1;
+const SEMVER_SPEC_VERSION = "2.0.0";
+const MAX_LENGTH$1 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+9007199254740991;
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+const RELEASE_TYPES = [
+  "major",
+  "premajor",
+  "minor",
+  "preminor",
+  "patch",
+  "prepatch",
+  "prerelease"
+];
+var constants = {
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 1,
+  FLAG_LOOSE: 2
+};
+var re$1 = { exports: {} };
+(function(module, exports) {
+  const {
+    MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2,
+    MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2,
+    MAX_LENGTH: MAX_LENGTH2
+  } = constants;
+  const debug2 = debug_1;
+  exports = module.exports = {};
+  const re2 = exports.re = [];
+  const safeRe = exports.safeRe = [];
+  const src = exports.src = [];
+  const t2 = exports.t = {};
+  let R = 0;
+  const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+  const safeRegexReplacements = [
+    ["\\s", 1],
+    ["\\d", MAX_LENGTH2],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2]
+  ];
+  const makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value;
+  };
+  const createToken = (name, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
+    const index = R++;
+    debug2(name, index, value);
+    t2[name] = index;
+    src[index] = value;
+    re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+    safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+  };
+  createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+  createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+  createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
+  createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
+  createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+  createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
+  createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
+  createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
+  createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
+  createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
+  createToken("GTLT", "((?:<|>)?=?)");
+  createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
+  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
+  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
+  createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
+  createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`);
+  createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
+  createToken("COERCERTL", src[t2.COERCE], true);
+  createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
+  createToken("LONETILDE", "(?:~>?)");
+  createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+  exports.tildeTrimReplace = "$1~";
+  createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("LONECARET", "(?:\\^)");
+  createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
+  exports.caretTrimReplace = "$1^";
+  createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
+  createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
+  createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
+  createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
+  exports.comparatorTrimReplace = "$1$2$3";
+  createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
+  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
+  createToken("STAR", "(<|>)?=?\\s*\\*");
+  createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+})(re$1, re$1.exports);
+var reExports = re$1.exports;
+const looseOption = Object.freeze({ loose: true });
+const emptyOpts = Object.freeze({});
+const parseOptions$1 = (options) => {
+  if (!options) {
+    return emptyOpts;
+  }
+  if (typeof options !== "object") {
+    return looseOption;
+  }
+  return options;
+};
+var parseOptions_1 = parseOptions$1;
+const numeric = /^[0-9]+$/;
+const compareIdentifiers$1 = (a, b) => {
+  const anum = numeric.test(a);
+  const bnum = numeric.test(b);
+  if (anum && bnum) {
+    a = +a;
+    b = +b;
+  }
+  return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+};
+const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+var identifiers = {
+  compareIdentifiers: compareIdentifiers$1,
+  rcompareIdentifiers
+};
+const debug = debug_1;
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants;
+const { safeRe: re, t } = reExports;
+const parseOptions = parseOptions_1;
+const { compareIdentifiers } = identifiers;
+let SemVer$2 = class SemVer {
+  constructor(version, options) {
+    options = parseOptions(options);
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+        return version;
+      } else {
+        version = version.version;
+      }
+    } else if (typeof version !== "string") {
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+    }
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      );
+    }
+    debug("SemVer", version, options);
+    this.options = options;
+    this.loose = !!options.loose;
+    this.includePrerelease = !!options.includePrerelease;
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`);
+    }
+    this.raw = version;
+    this.major = +m[1];
+    this.minor = +m[2];
+    this.patch = +m[3];
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError("Invalid major version");
+    }
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError("Invalid minor version");
+    }
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError("Invalid patch version");
+    }
+    if (!m[4]) {
+      this.prerelease = [];
+    } else {
+      this.prerelease = m[4].split(".").map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id;
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num;
+          }
+        }
+        return id;
+      });
+    }
+    this.build = m[5] ? m[5].split(".") : [];
+    this.format();
+  }
+  format() {
+    this.version = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join(".")}`;
+    }
+    return this.version;
+  }
+  toString() {
+    return this.version;
+  }
+  compare(other) {
+    debug("SemVer.compare", this.version, this.options, other);
+    if (!(other instanceof SemVer)) {
+      if (typeof other === "string" && other === this.version) {
+        return 0;
+      }
+      other = new SemVer(other, this.options);
+    }
+    if (other.version === this.version) {
+      return 0;
+    }
+    return this.compareMain(other) || this.comparePre(other);
+  }
+  compareMain(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+  }
+  comparePre(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1;
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1;
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0;
+    }
+    let i = 0;
+    do {
+      const a = this.prerelease[i];
+      const b = other.prerelease[i];
+      debug("prerelease compare", i, a, b);
+      if (a === void 0 && b === void 0) {
+        return 0;
+      } else if (b === void 0) {
+        return 1;
+      } else if (a === void 0) {
+        return -1;
+      } else if (a === b) {
+        continue;
+      } else {
+        return compareIdentifiers(a, b);
+      }
+    } while (++i);
+  }
+  compareBuild(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    let i = 0;
+    do {
+      const a = this.build[i];
+      const b = other.build[i];
+      debug("build compare", i, a, b);
+      if (a === void 0 && b === void 0) {
+        return 0;
+      } else if (b === void 0) {
+        return 1;
+      } else if (a === void 0) {
+        return -1;
+      } else if (a === b) {
+        continue;
+      } else {
+        return compareIdentifiers(a, b);
+      }
+    } while (++i);
+  }
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc(release, identifier, identifierBase) {
+    switch (release) {
+      case "premajor":
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "preminor":
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "prepatch":
+        this.prerelease.length = 0;
+        this.inc("patch", identifier, identifierBase);
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "prerelease":
+        if (this.prerelease.length === 0) {
+          this.inc("patch", identifier, identifierBase);
+        }
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "major":
+        if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+          this.major++;
+        }
+        this.minor = 0;
+        this.patch = 0;
+        this.prerelease = [];
+        break;
+      case "minor":
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++;
+        }
+        this.patch = 0;
+        this.prerelease = [];
+        break;
+      case "patch":
+        if (this.prerelease.length === 0) {
+          this.patch++;
+        }
+        this.prerelease = [];
+        break;
+      case "pre": {
+        const base = Number(identifierBase) ? 1 : 0;
+        if (!identifier && identifierBase === false) {
+          throw new Error("invalid increment argument: identifier is empty");
+        }
+        if (this.prerelease.length === 0) {
+          this.prerelease = [base];
+        } else {
+          let i = this.prerelease.length;
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === "number") {
+              this.prerelease[i]++;
+              i = -2;
+            }
+          }
+          if (i === -1) {
+            if (identifier === this.prerelease.join(".") && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier already exists");
+            }
+            this.prerelease.push(base);
+          }
+        }
+        if (identifier) {
+          let prerelease = [identifier, base];
+          if (identifierBase === false) {
+            prerelease = [identifier];
+          }
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = prerelease;
+            }
+          } else {
+            this.prerelease = prerelease;
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`);
+    }
+    this.raw = this.format();
+    if (this.build.length) {
+      this.raw += `+${this.build.join(".")}`;
+    }
+    return this;
+  }
+};
+var semver = SemVer$2;
+const SemVer$1 = semver;
+const parse$1 = (version, options, throwErrors = false) => {
+  if (version instanceof SemVer$1) {
+    return version;
+  }
+  try {
+    return new SemVer$1(version, options);
+  } catch (er) {
+    if (!throwErrors) {
+      return null;
+    }
+    throw er;
+  }
+};
+var parse_1 = parse$1;
+const parse = parse_1;
+const valid = (version, options) => {
+  const v = parse(version, options);
+  return v ? v.version : null;
+};
+var valid_1 = valid;
+const valid$1 = /* @__PURE__ */ getDefaultExportFromCjs(valid_1);
+const SemVer2 = semver;
+const major = (a, loose) => new SemVer2(a, loose).major;
+var major_1 = major;
+const major$1 = /* @__PURE__ */ getDefaultExportFromCjs(major_1);
+class ProxyBus {
+  bus;
+  constructor(bus2) {
+    if (typeof bus2.getVersion !== "function" || !valid$1(bus2.getVersion())) {
+      console.warn("Proxying an event bus with an unknown or invalid version");
+    } else if (major$1(bus2.getVersion()) !== major$1(this.getVersion())) {
+      console.warn(
+        "Proxying an event bus of version " + bus2.getVersion() + " with " + this.getVersion()
+      );
+    }
+    this.bus = bus2;
+  }
+  getVersion() {
+    return "3.3.1";
+  }
+  subscribe(name, handler) {
+    this.bus.subscribe(name, handler);
+  }
+  unsubscribe(name, handler) {
+    this.bus.unsubscribe(name, handler);
+  }
+  emit(name, event) {
+    this.bus.emit(name, event);
+  }
+}
+class SimpleBus {
+  handlers = /* @__PURE__ */ new Map();
+  getVersion() {
+    return "3.3.1";
+  }
+  subscribe(name, handler) {
+    this.handlers.set(
+      name,
+      (this.handlers.get(name) || []).concat(
+        handler
+      )
+    );
+  }
+  unsubscribe(name, handler) {
+    this.handlers.set(
+      name,
+      (this.handlers.get(name) || []).filter((h) => h !== handler)
+    );
+  }
+  emit(name, event) {
+    (this.handlers.get(name) || []).forEach((h) => {
+      try {
+        h(event);
+      } catch (e) {
+        console.error("could not invoke event listener", e);
+      }
+    });
+  }
+}
+let bus = null;
+function getBus() {
+  if (bus !== null) {
+    return bus;
+  }
+  if (typeof window === "undefined") {
+    return new Proxy({}, {
+      get: () => {
+        return () => console.error(
+          "Window not available, EventBus can not be established!"
+        );
+      }
+    });
+  }
+  if (window.OC?._eventBus && typeof window._nc_event_bus === "undefined") {
+    console.warn(
+      "found old event bus instance at OC._eventBus. Update your version!"
+    );
+    window._nc_event_bus = window.OC._eventBus;
+  }
+  if (typeof window?._nc_event_bus !== "undefined") {
+    bus = new ProxyBus(window._nc_event_bus);
+  } else {
+    bus = window._nc_event_bus = new SimpleBus();
+  }
+  return bus;
+}
+function emit(name, event) {
+  getBus().emit(name, event);
+}
+/*!
+ * SPDX-FileCopyrightText: 2023 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+class FileListFilter extends TypedEventTarget {
+  id;
+  order;
+  constructor(id, order = 100) {
+    super();
+    this.id = id;
+    this.order = order;
+  }
+  filter(nodes) {
+    throw new Error("Not implemented");
+  }
+  updateChips(chips) {
+    this.dispatchTypedEvent("update:chips", new CustomEvent("update:chips", { detail: chips }));
+  }
+  filterUpdated() {
+    this.dispatchTypedEvent("update:filter", new CustomEvent("update:filter"));
+  }
+}
+function registerFileListFilter(filter) {
+  if (!window._nc_filelist_filters) {
+    window._nc_filelist_filters = /* @__PURE__ */ new Map();
+  }
+  if (window._nc_filelist_filters.has(filter.id)) {
+    throw new Error(`File list filter "${filter.id}" already registered`);
+  }
+  window._nc_filelist_filters.set(filter.id, filter);
+  emit("files:filter:added", filter);
+}
+function unregisterFileListFilter(filterId) {
+  if (window._nc_filelist_filters && window._nc_filelist_filters.has(filterId)) {
+    window._nc_filelist_filters.delete(filterId);
+    emit("files:filter:removed", filterId);
+  }
+}
+function getFileListFilters() {
+  if (!window._nc_filelist_filters) {
+    return [];
+  }
+  return [...window._nc_filelist_filters.values()];
+}
 const addNewFileMenuEntry = function(entry) {
   const newFileMenu = getNewFileMenu();
   return newFileMenu.registerEntry(entry);
@@ -2902,6 +3434,7 @@ export {
   DefaultType,
   File,
   FileAction,
+  FileListFilter,
   FileType,
   FilesSortingMode,
   Folder,
@@ -2932,6 +3465,7 @@ export {
   getDavProperties,
   getFavoriteNodes,
   getFileActions,
+  getFileListFilters,
   getFileListHeaders,
   getNavigation,
   getNewFileMenuEntries,
@@ -2941,8 +3475,10 @@ export {
   parseFileSize,
   registerDavProperty,
   registerFileAction,
+  registerFileListFilter,
   registerFileListHeaders,
   removeNewFileMenuEntry,
   sortNodes,
+  unregisterFileListFilter,
   validateFilename
 };