@holoviz/panel 1.5.0-a.3 → 1.5.0-a.5

package/dist/bundled/filedropper/filepond-plugin-file-validate-size/dist/filepond-plugin-file-validate-size.js

@@ -0,0 +1,173 @@
+/*!
+ * FilePondPluginFileValidateSize 2.2.8
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+
+(function(global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined'
+        ? (module.exports = factory())
+        : typeof define === 'function' && define.amd
+        ? define(factory)
+        : ((global = global || self), (global.FilePondPluginFileValidateSize = factory()));
+})(this, function() {
+    'use strict';
+
+    var plugin = function plugin(_ref) {
+        var addFilter = _ref.addFilter,
+            utils = _ref.utils;
+        // get quick reference to Type utils
+        var Type = utils.Type,
+            replaceInString = utils.replaceInString,
+            toNaturalFileSize = utils.toNaturalFileSize;
+
+        // filtering if an item is allowed in hopper
+        addFilter('ALLOW_HOPPER_ITEM', function(file, _ref2) {
+            var query = _ref2.query;
+            if (!query('GET_ALLOW_FILE_SIZE_VALIDATION')) {
+                return true;
+            }
+
+            var sizeMax = query('GET_MAX_FILE_SIZE');
+            if (sizeMax !== null && file.size > sizeMax) {
+                return false;
+            }
+
+            var sizeMin = query('GET_MIN_FILE_SIZE');
+            if (sizeMin !== null && file.size < sizeMin) {
+                return false;
+            }
+
+            return true;
+        });
+
+        // called for each file that is loaded
+        // right before it is set to the item state
+        // should return a promise
+        addFilter('LOAD_FILE', function(file, _ref3) {
+            var query = _ref3.query;
+            return new Promise(function(resolve, reject) {
+                // if not allowed, all fine, exit
+                if (!query('GET_ALLOW_FILE_SIZE_VALIDATION')) {
+                    return resolve(file);
+                }
+
+                // check if file should be filtered
+                var fileFilter = query('GET_FILE_VALIDATE_SIZE_FILTER');
+                if (fileFilter && !fileFilter(file)) {
+                    return resolve(file);
+                }
+
+                // reject or resolve based on file size
+                var sizeMax = query('GET_MAX_FILE_SIZE');
+                if (sizeMax !== null && file.size > sizeMax) {
+                    reject({
+                        status: {
+                            main: query('GET_LABEL_MAX_FILE_SIZE_EXCEEDED'),
+                            sub: replaceInString(query('GET_LABEL_MAX_FILE_SIZE'), {
+                                filesize: toNaturalFileSize(
+                                    sizeMax,
+                                    '.',
+                                    query('GET_FILE_SIZE_BASE'),
+                                    query('GET_FILE_SIZE_LABELS', query)
+                                ),
+                            }),
+                        },
+                    });
+
+                    return;
+                }
+
+                // reject or resolve based on file size
+                var sizeMin = query('GET_MIN_FILE_SIZE');
+                if (sizeMin !== null && file.size < sizeMin) {
+                    reject({
+                        status: {
+                            main: query('GET_LABEL_MIN_FILE_SIZE_EXCEEDED'),
+                            sub: replaceInString(query('GET_LABEL_MIN_FILE_SIZE'), {
+                                filesize: toNaturalFileSize(
+                                    sizeMin,
+                                    '.',
+                                    query('GET_FILE_SIZE_BASE'),
+                                    query('GET_FILE_SIZE_LABELS', query)
+                                ),
+                            }),
+                        },
+                    });
+
+                    return;
+                }
+
+                // returns the current option value
+                var totalSizeMax = query('GET_MAX_TOTAL_FILE_SIZE');
+                if (totalSizeMax !== null) {
+                    // get the current total file size
+                    var currentTotalSize = query('GET_ACTIVE_ITEMS').reduce(function(total, item) {
+                        return total + item.fileSize;
+                    }, 0);
+
+                    // get the size of the new file
+                    if (currentTotalSize > totalSizeMax) {
+                        reject({
+                            status: {
+                                main: query('GET_LABEL_MAX_TOTAL_FILE_SIZE_EXCEEDED'),
+                                sub: replaceInString(query('GET_LABEL_MAX_TOTAL_FILE_SIZE'), {
+                                    filesize: toNaturalFileSize(
+                                        totalSizeMax,
+                                        '.',
+                                        query('GET_FILE_SIZE_BASE'),
+                                        query('GET_FILE_SIZE_LABELS', query)
+                                    ),
+                                }),
+                            },
+                        });
+
+                        return;
+                    }
+                }
+
+                // file is fine, let's pass it back
+                resolve(file);
+            });
+        });
+
+        return {
+            options: {
+                // Enable or disable file type validation
+                allowFileSizeValidation: [true, Type.BOOLEAN],
+
+                // Max individual file size in bytes
+                maxFileSize: [null, Type.INT],
+
+                // Min individual file size in bytes
+                minFileSize: [null, Type.INT],
+
+                // Max total file size in bytes
+                maxTotalFileSize: [null, Type.INT],
+
+                // Filter the files that need to be validated for size
+                fileValidateSizeFilter: [null, Type.FUNCTION],
+
+                // error labels
+                labelMinFileSizeExceeded: ['File is too small', Type.STRING],
+                labelMinFileSize: ['Minimum file size is {filesize}', Type.STRING],
+
+                labelMaxFileSizeExceeded: ['File is too large', Type.STRING],
+                labelMaxFileSize: ['Maximum file size is {filesize}', Type.STRING],
+
+                labelMaxTotalFileSizeExceeded: ['Maximum total size exceeded', Type.STRING],
+                labelMaxTotalFileSize: ['Maximum total file size is {filesize}', Type.STRING],
+            },
+        };
+    };
+
+    // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags
+    var isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    if (isBrowser) {
+        document.dispatchEvent(new CustomEvent('FilePond:pluginloaded', { detail: plugin }));
+    }
+
+    return plugin;
+});

package/dist/bundled/filedropper/filepond-plugin-file-validate-type/dist/filepond-plugin-file-validate-type.js

@@ -0,0 +1,231 @@
+/*!
+ * FilePondPluginFileValidateType 1.2.9
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+
+(function(global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined'
+        ? (module.exports = factory())
+        : typeof define === 'function' && define.amd
+        ? define(factory)
+        : ((global = global || self), (global.FilePondPluginFileValidateType = factory()));
+})(this, function() {
+    'use strict';
+
+    var plugin = function plugin(_ref) {
+        var addFilter = _ref.addFilter,
+            utils = _ref.utils;
+        // get quick reference to Type utils
+        var Type = utils.Type,
+            isString = utils.isString,
+            replaceInString = utils.replaceInString,
+            guesstimateMimeType = utils.guesstimateMimeType,
+            getExtensionFromFilename = utils.getExtensionFromFilename,
+            getFilenameFromURL = utils.getFilenameFromURL;
+
+        var mimeTypeMatchesWildCard = function mimeTypeMatchesWildCard(mimeType, wildcard) {
+            var mimeTypeGroup = (/^[^/]+/.exec(mimeType) || []).pop(); // image/png -> image
+            var wildcardGroup = wildcard.slice(0, -2); // image/* -> image
+            return mimeTypeGroup === wildcardGroup;
+        };
+
+        var isValidMimeType = function isValidMimeType(acceptedTypes, userInputType) {
+            return acceptedTypes.some(function(acceptedType) {
+                // accepted is wildcard mime type
+                if (/\*$/.test(acceptedType)) {
+                    return mimeTypeMatchesWildCard(userInputType, acceptedType);
+                }
+
+                // is normal mime type
+                return acceptedType === userInputType;
+            });
+        };
+
+        var getItemType = function getItemType(item) {
+            // if the item is a url we guess the mime type by the extension
+            var type = '';
+            if (isString(item)) {
+                var filename = getFilenameFromURL(item);
+                var extension = getExtensionFromFilename(filename);
+                if (extension) {
+                    type = guesstimateMimeType(extension);
+                }
+            } else {
+                type = item.type;
+            }
+
+            return type;
+        };
+
+        var validateFile = function validateFile(item, acceptedFileTypes, typeDetector) {
+            // no types defined, everything is allowed \o/
+            if (acceptedFileTypes.length === 0) {
+                return true;
+            }
+
+            // gets the item type
+            var type = getItemType(item);
+
+            // no type detector, test now
+            if (!typeDetector) {
+                return isValidMimeType(acceptedFileTypes, type);
+            }
+
+            // use type detector
+            return new Promise(function(resolve, reject) {
+                typeDetector(item, type)
+                    .then(function(detectedType) {
+                        if (isValidMimeType(acceptedFileTypes, detectedType)) {
+                            resolve();
+                        } else {
+                            reject();
+                        }
+                    })
+                    .catch(reject);
+            });
+        };
+
+        var applyMimeTypeMap = function applyMimeTypeMap(map) {
+            return function(acceptedFileType) {
+                return map[acceptedFileType] === null
+                    ? false
+                    : map[acceptedFileType] || acceptedFileType;
+            };
+        };
+
+        // setup attribute mapping for accept
+        addFilter('SET_ATTRIBUTE_TO_OPTION_MAP', function(map) {
+            return Object.assign(map, {
+                accept: 'acceptedFileTypes',
+            });
+        });
+
+        // filtering if an item is allowed in hopper
+        addFilter('ALLOW_HOPPER_ITEM', function(file, _ref2) {
+            var query = _ref2.query;
+            // if we are not doing file type validation exit
+            if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {
+                return true;
+            }
+
+            // we validate the file against the accepted file types
+            return validateFile(file, query('GET_ACCEPTED_FILE_TYPES'));
+        });
+
+        // called for each file that is loaded
+        // right before it is set to the item state
+        // should return a promise
+        addFilter('LOAD_FILE', function(file, _ref3) {
+            var query = _ref3.query;
+            return new Promise(function(resolve, reject) {
+                if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {
+                    resolve(file);
+                    return;
+                }
+
+                var acceptedFileTypes = query('GET_ACCEPTED_FILE_TYPES');
+
+                // custom type detector method
+                var typeDetector = query('GET_FILE_VALIDATE_TYPE_DETECT_TYPE');
+
+                // if invalid, exit here
+                var validationResult = validateFile(file, acceptedFileTypes, typeDetector);
+
+                var handleRejection = function handleRejection() {
+                    var acceptedFileTypesMapped = acceptedFileTypes
+                        .map(
+                            applyMimeTypeMap(
+                                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES_MAP')
+                            )
+                        )
+                        .filter(function(label) {
+                            return label !== false;
+                        });
+
+                    var acceptedFileTypesMappedUnique = acceptedFileTypesMapped.filter(function(
+                        item,
+                        index
+                    ) {
+                        return acceptedFileTypesMapped.indexOf(item) === index;
+                    });
+
+                    reject({
+                        status: {
+                            main: query('GET_LABEL_FILE_TYPE_NOT_ALLOWED'),
+                            sub: replaceInString(
+                                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES'),
+                                {
+                                    allTypes: acceptedFileTypesMappedUnique.join(', '),
+                                    allButLastType: acceptedFileTypesMappedUnique
+                                        .slice(0, -1)
+                                        .join(', '),
+                                    lastType:
+                                        acceptedFileTypesMappedUnique[
+                                            acceptedFileTypesMappedUnique.length - 1
+                                        ],
+                                }
+                            ),
+                        },
+                    });
+                };
+
+                // has returned new filename immidiately
+                if (typeof validationResult === 'boolean') {
+                    if (!validationResult) {
+                        return handleRejection();
+                    }
+                    return resolve(file);
+                }
+
+                // is promise
+                validationResult
+                    .then(function() {
+                        resolve(file);
+                    })
+                    .catch(handleRejection);
+            });
+        });
+
+        // expose plugin
+        return {
+            // default options
+            options: {
+                // Enable or disable file type validation
+                allowFileTypeValidation: [true, Type.BOOLEAN],
+
+                // What file types to accept
+                acceptedFileTypes: [[], Type.ARRAY],
+                // - must be comma separated
+                // - mime types: image/png, image/jpeg, image/gif
+                // - extensions: .png, .jpg, .jpeg ( not enabled yet )
+                // - wildcards: image/*
+
+                // label to show when a type is not allowed
+                labelFileTypeNotAllowed: ['File is of invalid type', Type.STRING],
+
+                // nicer label
+                fileValidateTypeLabelExpectedTypes: [
+                    'Expects {allButLastType} or {lastType}',
+                    Type.STRING,
+                ],
+
+                // map mime types to extensions
+                fileValidateTypeLabelExpectedTypesMap: [{}, Type.OBJECT],
+
+                // Custom function to detect type of file
+                fileValidateTypeDetectType: [null, Type.FUNCTION],
+            },
+        };
+    };
+
+    // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags
+    var isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    if (isBrowser) {
+        document.dispatchEvent(new CustomEvent('FilePond:pluginloaded', { detail: plugin }));
+    }
+
+    return plugin;
+});

package/dist/bundled/filedropper/filepond-plugin-image-preview/dist/filepond-plugin-image-preview.css

@@ -0,0 +1,163 @@
+/*!
+ * FilePondPluginImagePreview 4.6.12
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+.filepond--image-preview-markup {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+.filepond--image-preview-wrapper {
+  z-index: 2;
+}
+.filepond--image-preview-overlay {
+  display: block;
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  min-height: 5rem;
+  max-height: 7rem;
+  margin: 0;
+  opacity: 0;
+  z-index: 2;
+  pointer-events: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+.filepond--image-preview-overlay svg {
+  width: 100%;
+  height: auto;
+  color: inherit;
+  max-height: inherit;
+}
+.filepond--image-preview-overlay-idle {
+  mix-blend-mode: multiply;
+  color: rgba(40, 40, 40, 0.85);
+}
+.filepond--image-preview-overlay-success {
+  mix-blend-mode: normal;
+  color: rgba(54, 151, 99, 1);
+}
+.filepond--image-preview-overlay-failure {
+  mix-blend-mode: normal;
+  color: rgba(196, 78, 71, 1);
+}
+/* disable for Safari as mix-blend-mode causes the overflow:hidden of the parent container to not work */
+@supports (-webkit-marquee-repetition: infinite) and
+  ((-o-object-fit: fill) or (object-fit: fill)) {
+  .filepond--image-preview-overlay-idle {
+    mix-blend-mode: normal;
+  }
+}
+.filepond--image-preview-wrapper {
+  /* no interaction */
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+
+  /* have preview fill up all available space */
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  height: 100%;
+  margin: 0;
+
+  /* radius is .05em less to prevent the panel background color from shining through */
+  border-radius: 0.45em;
+  overflow: hidden;
+
+  /* this seems to prevent Chrome from redrawing this layer constantly */
+  background: rgba(0, 0, 0, 0.01);
+}
+.filepond--image-preview {
+  position: absolute;
+  left: 0;
+  top: 0;
+  z-index: 1;
+  display: flex; /* this aligns the graphic vertically if the panel is higher than the image */
+  align-items: center;
+  height: 100%;
+  width: 100%;
+  pointer-events: none;
+  background: #222;
+
+  /* will be animated */
+  will-change: transform, opacity;
+}
+.filepond--image-clip {
+  position: relative;
+  overflow: hidden;
+  margin: 0 auto;
+
+  /* transparency indicator (currently only supports grid or basic color) */
+}
+.filepond--image-clip[data-transparency-indicator='grid'] img,
+.filepond--image-clip[data-transparency-indicator='grid'] canvas {
+  background-color: #fff;
+  background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 100 100' xmlns='http://www.w3.org/2000/svg' fill='%23eee'%3E%3Cpath d='M0 0 H50 V50 H0'/%3E%3Cpath d='M50 50 H100 V100 H50'/%3E%3C/svg%3E");
+  background-size: 1.25em 1.25em;
+}
+.filepond--image-bitmap,
+.filepond--image-vector {
+  position: absolute;
+  left: 0;
+  top: 0;
+  will-change: transform;
+}
+.filepond--root[data-style-panel-layout~='integrated']
+  .filepond--image-preview-wrapper {
+  border-radius: 0;
+}
+.filepond--root[data-style-panel-layout~='integrated']
+  .filepond--image-preview {
+  height: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--image-preview-wrapper {
+  border-radius: 99999rem;
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--image-preview-overlay {
+  top: auto;
+  bottom: 0;
+  -webkit-transform: scaleY(-1);
+  transform: scaleY(-1);
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--file
+  .filepond--file-action-button[data-align*='bottom']:not([data-align*='center']) {
+  margin-bottom: 0.325em;
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--file
+  [data-align*='left'] {
+  left: calc(50% - 3em);
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--file
+  [data-align*='right'] {
+  right: calc(50% - 3em);
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--progress-indicator[data-align*='bottom'][data-align*='left'],
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--progress-indicator[data-align*='bottom'][data-align*='right'] {
+  margin-bottom: calc(0.325em + 0.1875em);
+}
+.filepond--root[data-style-panel-layout~='circle']
+  .filepond--progress-indicator[data-align*='bottom'][data-align*='center'] {
+  margin-top: 0;
+  margin-bottom: 0.1875em;
+  margin-left: 0.1875em;
+}