@nextcloud/files 2.1.0 → 3.0.0-beta.10

package/dist/index.js

@@ -1,14 +1,889 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "formatFileSize", {
-  enumerable: true,
-  get: function get() {
-    return _humanfilesize.formatFileSize;
-  }
-});
-
-var _humanfilesize = require("./humanfilesize");
-//# sourceMappingURL=index.js.map
+'use strict';
+
+var l10n = require('@nextcloud/l10n');
+var auth = require('@nextcloud/auth');
+var logger$1 = require('@nextcloud/logger');
+var path = require('path');
+
+/**
+ * @copyright 2019 Christoph Wurst <christoph@winzerhof-wurst.at>
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+var humanList = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+var humanListBinary = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'];
+/**
+ * Format a file size in a human-like format. e.g. 42GB
+ *
+ * @param size in bytes
+ * @param skipSmallSizes avoid rendering tiny sizes and return '< 1 KB' instead
+ */
+function formatFileSize(size, skipSmallSizes, binaryPrefixes) {
+    if (skipSmallSizes === void 0) { skipSmallSizes = false; }
+    if (binaryPrefixes === void 0) { binaryPrefixes = false; }
+    if (typeof size === 'string') {
+        size = Number(size);
+    }
+    /*
+    * @note This block previously used Log base 1024, per IEC 80000-13;
+    * however, the wrong prefix was used. Now we use decimal calculation
+    * with base 1000 per the SI. Base 1024 calculation with binary
+    * prefixes is optional, but has yet to be added to the UI.
+    */
+    // Calculate Log with base 1024 or 1000: size = base ** order
+    var order = size > 0 ? Math.floor(Math.log(size) / Math.log(binaryPrefixes ? 1024 : 1000)) : 0;
+    // Stay in range of the byte sizes that are defined
+    order = Math.min((binaryPrefixes ? humanListBinary.length : humanList.length) - 1, order);
+    var readableFormat = binaryPrefixes ? humanListBinary[order] : humanList[order];
+    var relativeSize = (size / Math.pow(binaryPrefixes ? 1024 : 1000, order)).toFixed(1);
+    if (skipSmallSizes === true && order === 0) {
+        return (relativeSize !== '0.0' ? '< 1 ' : '0 ') + (binaryPrefixes ? humanListBinary[1] : humanList[1]);
+    }
+    if (order < 2) {
+        relativeSize = parseFloat(relativeSize).toFixed(0);
+    }
+    else {
+        relativeSize = parseFloat(relativeSize).toLocaleString(l10n.getCanonicalLocale());
+    }
+    return relativeSize + ' ' + readableFormat;
+}
+
+/**
+ * @copyright 2019 Christoph Wurst <christoph@winzerhof-wurst.at>
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+var getLogger = function (user) {
+    if (user === null) {
+        return logger$1.getLoggerBuilder()
+            .setApp('files')
+            .build();
+    }
+    return logger$1.getLoggerBuilder()
+        .setApp('files')
+        .setUid(user.uid)
+        .build();
+};
+var logger = getLogger(auth.getCurrentUser());
+
+/**
+ * @copyright Copyright (c) 2021 John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+var NewFileMenu = /** @class */ (function () {
+    function NewFileMenu() {
+        this._entries = [];
+    }
+    NewFileMenu.prototype.registerEntry = function (entry) {
+        this.validateEntry(entry);
+        this._entries.push(entry);
+    };
+    NewFileMenu.prototype.unregisterEntry = function (entry) {
+        var entryIndex = typeof entry === 'string'
+            ? this.getEntryIndex(entry)
+            : this.getEntryIndex(entry.id);
+        if (entryIndex === -1) {
+            logger.warn('Entry not found, nothing removed', { entry: entry, entries: this.getEntries() });
+            return;
+        }
+        this._entries.splice(entryIndex, 1);
+    };
+    /**
+     * Get the list of registered entries
+     *
+     * @param {FileInfo} context the creation context. Usually the current folder FileInfo
+     */
+    NewFileMenu.prototype.getEntries = function (context) {
+        if (context) {
+            return this._entries
+                .filter(function (entry) { return typeof entry.if === 'function' ? entry.if(context) : true; });
+        }
+        return this._entries;
+    };
+    NewFileMenu.prototype.getEntryIndex = function (id) {
+        return this._entries.findIndex(function (entry) { return entry.id === id; });
+    };
+    NewFileMenu.prototype.validateEntry = function (entry) {
+        if (!entry.id || !entry.displayName || !(entry.iconSvgInline || entry.iconClass)) {
+            throw new Error('Invalid entry');
+        }
+        if (typeof entry.id !== 'string'
+            || typeof entry.displayName !== 'string') {
+            throw new Error('Invalid id or displayName property');
+        }
+        if ((entry.iconClass && typeof entry.iconClass !== 'string')
+            || (entry.iconSvgInline && typeof entry.iconSvgInline !== 'string')) {
+            throw new Error('Invalid icon provided');
+        }
+        if (entry.if !== undefined && typeof entry.if !== 'function') {
+            throw new Error('Invalid if property');
+        }
+        if (entry.templateName && typeof entry.templateName !== 'string') {
+            throw new Error('Invalid templateName property');
+        }
+        if (entry.handler && typeof entry.handler !== 'function') {
+            throw new Error('Invalid handler property');
+        }
+        if (!entry.templateName && !entry.handler) {
+            throw new Error('At least a templateName or a handler must be provided');
+        }
+        if (this.getEntryIndex(entry.id) !== -1) {
+            throw new Error('Duplicate entry');
+        }
+    };
+    return NewFileMenu;
+}());
+var getNewFileMenu = function () {
+    if (typeof window._nc_newfilemenu === 'undefined') {
+        window._nc_newfilemenu = new NewFileMenu();
+        logger.debug('NewFileMenu initialized');
+    }
+    return window._nc_newfilemenu;
+};
+
+/**
+ * @copyright Copyright (c) 2022 John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+exports.FileType = void 0;
+(function (FileType) {
+    FileType["Folder"] = "folder";
+    FileType["File"] = "file";
+})(exports.FileType || (exports.FileType = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+/**
+ * @copyright Copyright (c) 2022 John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+exports.Permission = void 0;
+(function (Permission) {
+    Permission[Permission["NONE"] = 0] = "NONE";
+    Permission[Permission["CREATE"] = 4] = "CREATE";
+    Permission[Permission["READ"] = 1] = "READ";
+    Permission[Permission["UPDATE"] = 2] = "UPDATE";
+    Permission[Permission["DELETE"] = 8] = "DELETE";
+    Permission[Permission["SHARE"] = 16] = "SHARE";
+    Permission[Permission["ALL"] = 31] = "ALL";
+})(exports.Permission || (exports.Permission = {}));
+/**
+ * Parse the webdav permission string to a permission enum
+ * @see https://github.com/nextcloud/server/blob/71f698649f578db19a22457cb9d420fb62c10382/lib/public/Files/DavUtil.php#L58-L88
+ */
+var parseWebdavPermissions = function (permString) {
+    if (permString === void 0) { permString = ''; }
+    var permissions = exports.Permission.NONE;
+    if (!permString)
+        return permissions;
+    if (permString.includes('C') || permString.includes('K'))
+        permissions |= exports.Permission.CREATE;
+    if (permString.includes('G'))
+        permissions |= exports.Permission.READ;
+    if (permString.includes('W') || permString.includes('N') || permString.includes('V'))
+        permissions |= exports.Permission.UPDATE;
+    if (permString.includes('D'))
+        permissions |= exports.Permission.DELETE;
+    if (permString.includes('R'))
+        permissions |= exports.Permission.SHARE;
+    return permissions;
+};
+
+/**
+ * @copyright Copyright (c) 2022 John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+var isDavRessource = function (source, davService) {
+    return source.match(davService) !== null;
+};
+/**
+ * Validate Node construct data
+ */
+var validateData = function (data, davService) {
+    if ('id' in data && (typeof data.id !== 'number' || data.id < 0)) {
+        throw new Error('Invalid id type of value');
+    }
+    if (!data.source) {
+        throw new Error('Missing mandatory source');
+    }
+    try {
+        new URL(data.source);
+    }
+    catch (e) {
+        throw new Error('Invalid source format, source must be a valid URL');
+    }
+    if (!data.source.startsWith('http')) {
+        throw new Error('Invalid source format, only http(s) is supported');
+    }
+    if ('mtime' in data && !(data.mtime instanceof Date)) {
+        throw new Error('Invalid mtime type');
+    }
+    if ('crtime' in data && !(data.crtime instanceof Date)) {
+        throw new Error('Invalid crtime type');
+    }
+    if (!data.mime || typeof data.mime !== 'string'
+        || !data.mime.match(/^[-\w.]+\/[-+\w.]+$/gi)) {
+        throw new Error('Missing or invalid mandatory mime');
+    }
+    if ('size' in data && typeof data.size !== 'number') {
+        throw new Error('Invalid size type');
+    }
+    if ('permissions' in data && !(typeof data.permissions === 'number'
+        && data.permissions >= exports.Permission.NONE
+        && data.permissions <= exports.Permission.ALL)) {
+        throw new Error('Invalid permissions');
+    }
+    if ('owner' in data
+        && data.owner !== null
+        && typeof data.owner !== 'string') {
+        throw new Error('Invalid owner type');
+    }
+    if ('attributes' in data && typeof data.attributes !== 'object') {
+        throw new Error('Invalid attributes format');
+    }
+    if ('root' in data && typeof data.root !== 'string') {
+        throw new Error('Invalid root format');
+    }
+    if (data.root && !data.root.startsWith('/')) {
+        throw new Error('Root must start with a leading slash');
+    }
+    if (data.root && !data.source.includes(data.root)) {
+        throw new Error('Root must be part of the source');
+    }
+    if (data.root && isDavRessource(data.source, davService)) {
+        var service = data.source.match(davService)[0];
+        if (!data.source.includes(path.join(service, data.root))) {
+            throw new Error('The root must be relative to the service. e.g /files/emma');
+        }
+    }
+};
+
+var Node = /** @class */ (function () {
+    function Node(data, davService) {
+        var _this = this;
+        this._knownDavService = /(remote|public)\.php\/(web)?dav/i;
+        // Validate data
+        validateData(data, davService || this._knownDavService);
+        this._data = data;
+        var handler = {
+            set: function (target, prop, value) {
+                // Edit modification time
+                _this._data['mtime'] = new Date();
+                // Apply original changes
+                return Reflect.set(target, prop, value);
+            },
+            deleteProperty: function (target, prop) {
+                // Edit modification time
+                _this._data['mtime'] = new Date();
+                // Apply original changes
+                return Reflect.deleteProperty(target, prop);
+            },
+        };
+        // Proxy the attributes to update the mtime on change
+        this._attributes = new Proxy(data.attributes || {}, handler);
+        delete this._data.attributes;
+        if (davService) {
+            this._knownDavService = davService;
+        }
+    }
+    Object.defineProperty(Node.prototype, "source", {
+        /**
+         * Get the source url to this object
+         */
+        get: function () {
+            // strip any ending slash
+            return this._data.source.replace(/\/$/i, '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "basename", {
+        /**
+         * Get this object name
+         */
+        get: function () {
+            return path.basename(this.source);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "extension", {
+        /**
+         * Get this object's extension
+         */
+        get: function () {
+            return path.extname(this.source);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "dirname", {
+        /**
+         * Get the directory path leading to this object
+         * Will use the relative path to root if available
+         */
+        get: function () {
+            if (this.root) {
+                // Using replace would remove all part matching root
+                var firstMatch = this.source.indexOf(this.root);
+                return path.dirname(this.source.slice(firstMatch + this.root.length) || '/');
+            }
+            // This should always be a valid URL
+            // as this is tested in the constructor
+            var url = new URL(this.source);
+            return path.dirname(url.pathname);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "mime", {
+        /**
+         * Get the file mime
+         */
+        get: function () {
+            return this._data.mime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "mtime", {
+        /**
+         * Get the file modification time
+         */
+        get: function () {
+            return this._data.mtime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "crtime", {
+        /**
+         * Get the file creation time
+         */
+        get: function () {
+            return this._data.crtime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "size", {
+        /**
+         * Get the file size
+         */
+        get: function () {
+            return this._data.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "attributes", {
+        /**
+         * Get the file attribute
+         */
+        get: function () {
+            return this._attributes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "permissions", {
+        /**
+         * Get the file permissions
+         */
+        get: function () {
+            // If this is not a dav ressource, we can only read it
+            if (this.owner === null && !this.isDavRessource) {
+                return exports.Permission.READ;
+            }
+            // If the permissions are not defined, we have none
+            return this._data.permissions !== undefined
+                ? this._data.permissions
+                : exports.Permission.NONE;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "owner", {
+        /**
+         * Get the file owner
+         */
+        get: function () {
+            // Remote ressources have no owner
+            if (!this.isDavRessource) {
+                return null;
+            }
+            return this._data.owner;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "isDavRessource", {
+        /**
+         * Is this a dav-related ressource ?
+         */
+        get: function () {
+            return isDavRessource(this.source, this._knownDavService);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "root", {
+        /**
+         * Get the dav root of this object
+         */
+        get: function () {
+            // If provided (recommended), use the root and strip away the ending slash
+            if (this._data.root) {
+                return this._data.root.replace(/^(.+)\/$/, '$1');
+            }
+            // Use the source to get the root from the dav service
+            if (this.isDavRessource) {
+                var root = path.dirname(this.source);
+                return root.split(this._knownDavService).pop() || null;
+            }
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "path", {
+        /**
+         * Get the absolute path of this object relative to the root
+         */
+        get: function () {
+            if (this.root) {
+                // Using replace would remove all part matching root
+                var firstMatch = this.source.indexOf(this.root);
+                return this.source.slice(firstMatch + this.root.length) || '/';
+            }
+            return (this.dirname + '/' + this.basename).replace(/\/\//g, '/');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "fileid", {
+        /**
+         * Get the file id if defined in attributes
+         */
+        get: function () {
+            var _a;
+            return (_a = this.attributes) === null || _a === void 0 ? void 0 : _a.fileid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Move the node to a new destination
+     *
+     * @param {string} destination the new source.
+     * e.g. https://cloud.domain.com/remote.php/dav/files/emma/Photos/picture.jpg
+     */
+    Node.prototype.move = function (destination) {
+        validateData(__assign(__assign({}, this._data), { source: destination }), this._knownDavService);
+        this._data.source = destination;
+        this._data.mtime = new Date();
+    };
+    /**
+     * Rename the node
+     * This aliases the move method for easier usage
+     */
+    Node.prototype.rename = function (basename) {
+        if (basename.includes('/')) {
+            throw new Error('Invalid basename');
+        }
+        this.move(path.dirname(this.source) + '/' + basename);
+    };
+    return Node;
+}());
+
+var File = /** @class */ (function (_super) {
+    __extends(File, _super);
+    function File() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(File.prototype, "type", {
+        get: function () {
+            return exports.FileType.File;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return File;
+}(Node));
+
+var Folder = /** @class */ (function (_super) {
+    __extends(Folder, _super);
+    function Folder(data) {
+        // enforcing mimes
+        return _super.call(this, __assign(__assign({}, data), { mime: 'httpd/unix-directory' })) || this;
+    }
+    Object.defineProperty(Folder.prototype, "type", {
+        get: function () {
+            return exports.FileType.Folder;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Folder.prototype, "extension", {
+        get: function () {
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Folder.prototype, "mime", {
+        get: function () {
+            return 'httpd/unix-directory';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Folder;
+}(Node));
+
+/**
+ * @copyright Copyright (c) 2021 John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+var FileAction = /** @class */ (function () {
+    function FileAction(action) {
+        this.validateAction(action);
+        this._action = action;
+    }
+    Object.defineProperty(FileAction.prototype, "id", {
+        get: function () {
+            return this._action.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "displayName", {
+        get: function () {
+            return this._action.displayName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "iconSvgInline", {
+        get: function () {
+            return this._action.iconSvgInline;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "enabled", {
+        get: function () {
+            return this._action.enabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "exec", {
+        get: function () {
+            return this._action.exec;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "execBatch", {
+        get: function () {
+            return this._action.execBatch;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "order", {
+        get: function () {
+            return this._action.order;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "default", {
+        get: function () {
+            return this._action.default;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "inline", {
+        get: function () {
+            return this._action.inline;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileAction.prototype, "renderInline", {
+        get: function () {
+            return this._action.renderInline;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FileAction.prototype.validateAction = function (action) {
+        if (!action.id || typeof action.id !== 'string') {
+            throw new Error('Invalid id');
+        }
+        if (!action.displayName || typeof action.displayName !== 'function') {
+            throw new Error('Invalid displayName function');
+        }
+        if (!action.iconSvgInline || typeof action.iconSvgInline !== 'function') {
+            throw new Error('Invalid iconSvgInline function');
+        }
+        if (!action.exec || typeof action.exec !== 'function') {
+            throw new Error('Invalid exec function');
+        }
+        // Optional properties --------------------------------------------
+        if ('enabled' in action && typeof action.enabled !== 'function') {
+            throw new Error('Invalid enabled function');
+        }
+        if ('execBatch' in action && typeof action.execBatch !== 'function') {
+            throw new Error('Invalid execBatch function');
+        }
+        if ('order' in action && typeof action.order !== 'number') {
+            throw new Error('Invalid order');
+        }
+        if ('default' in action && typeof action.default !== 'boolean') {
+            throw new Error('Invalid default');
+        }
+        if ('inline' in action && typeof action.inline !== 'function') {
+            throw new Error('Invalid inline function');
+        }
+        if ('renderInline' in action && typeof action.renderInline !== 'function') {
+            throw new Error('Invalid renderInline function');
+        }
+    };
+    return FileAction;
+}());
+var registerFileAction = function (action) {
+    if (typeof window._nc_fileactions === 'undefined') {
+        window._nc_fileactions = [];
+        logger.debug('FileActions initialized');
+    }
+    // Check duplicates
+    if (window._nc_fileactions.find(function (search) { return search.id === action.id; })) {
+        logger.error("FileAction ".concat(action.id, " already registered"), { action: action });
+        return;
+    }
+    window._nc_fileactions.push(action);
+};
+var getFileActions = function () {
+    return window._nc_fileactions || [];
+};
+
+/**
+ * @copyright 2019 Christoph Wurst <christoph@winzerhof-wurst.at>
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ *
+ * @license AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/**
+ * Add a new menu entry to the upload manager menu
+ */
+var addNewFileMenuEntry = function (entry) {
+    var newFileMenu = getNewFileMenu();
+    return newFileMenu.registerEntry(entry);
+};
+/**
+ * Remove a previously registered entry from the upload menu
+ */
+var removeNewFileMenuEntry = function (entry) {
+    var newFileMenu = getNewFileMenu();
+    return newFileMenu.unregisterEntry(entry);
+};
+/**
+ * Get the list of registered entries from the upload menu
+ *
+ * @param {FileInfo} context the creation context. Usually the current folder FileInfo
+ */
+var getNewFileMenuEntries = function (context) {
+    var newFileMenu = getNewFileMenu();
+    return newFileMenu.getEntries(context);
+};
+
+exports.File = File;
+exports.FileAction = FileAction;
+exports.Folder = Folder;
+exports.Node = Node;
+exports.addNewFileMenuEntry = addNewFileMenuEntry;
+exports.formatFileSize = formatFileSize;
+exports.getFileActions = getFileActions;
+exports.getNewFileMenuEntries = getNewFileMenuEntries;
+exports.parseWebdavPermissions = parseWebdavPermissions;
+exports.registerFileAction = registerFileAction;
+exports.removeNewFileMenuEntry = removeNewFileMenuEntry;
+//# sourceMappingURL=index.js.map