studiokit-scaffolding-js 4.5.1 → 4.5.2-next.3.1

package/lib/components/HOC/ActivityRequiredComponent.d.ts

@@ -4,6 +4,7 @@ import { BaseReduxState, OptionalRecord } from '../../types';
 import { ActivityOptions } from '../../utils/baseActivity';
 export interface ActivityRequiredStateProps {
     hasAccess: boolean;
+    redirectPath: string;
 }
 export declare const configureActivityRequiredComponent: <TOwnProps extends {}>(WrappedComponent: React.ComponentType<TOwnProps>) => {
     new (props: (TOwnProps & ActivityRequiredStateProps) | Readonly<TOwnProps & ActivityRequiredStateProps>): {
@@ -60,15 +61,14 @@ export declare const configureActivityRequiredComponent: <TOwnProps extends {}>(
 };
 /**
  * Return `mapStateToProps` function. Add a `hasAccess` boolean property to the component's props
- * checking whether the user has the passed `requiredActivity`
+ * checking whether the user has the passed `requiredActivity`.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty (Optional) The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty?: string | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
+export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty?: string | undefined, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
 /**
  * This HOC ensures that the wrapped component is only rendered if the predicate provided is satisfied.
  *
@@ -78,15 +78,14 @@ export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPred
  * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
  * parameter. It can be ignored if not needed by the lambda.
  *
- * @param {Component} WrappedComponent The component which requires activity/activities in order to render
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function activityRequiredComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string): ComponentClass<TOwnProps>;
+export default function activityRequiredComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined): ComponentClass<TOwnProps>;
 /**
- * This HOC ensures that the wrapped component is rendered iff the predicate provided is satisfied.
+ * This HOC ensures that the wrapped component is rendered if the predicate provided is satisfied.
  *
  * Typically this component is used by passing one of the functions in utils/activities as the
  * `accessPredicate` and a constant from "constants/activities" as the `requiredActivity`.
@@ -94,12 +93,10 @@ export default function activityRequiredComponent<TOwnProps extends {}>(WrappedC
  * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
  * and `modelsProperty` parameters. They can be ignored if not needed by the lambda.
  *
- * @param {Component} WrappedComponent The component which requires activity/activities in order to render
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
- *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function activityRequiredComponent<TOwnProps extends {}, TPropName extends string>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string, modelsProperty: TPropName): ComponentClass<TOwnProps & OptionalRecord<TPropName, Model>>;
+export default function activityRequiredComponent<TOwnProps extends {}, TPropName extends string>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty: TPropName, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined): ComponentClass<TOwnProps & OptionalRecord<TPropName, Model>>;

package/lib/components/HOC/ActivityRequiredComponent.js

@@ -66,9 +66,9 @@ var configureActivityRequiredComponent = function (WrappedComponent) {
             return _super !== null && _super.apply(this, arguments) || this;
         }
         ActivityRequiredComponent.prototype.render = function () {
-            var _a = this.props, hasAccess = _a.hasAccess, rest = __rest(_a, ["hasAccess"]);
-            if (!this.props.hasAccess) {
-                return react_1.default.createElement(react_router_dom_1.Redirect, { to: '/' });
+            var _a = this.props, hasAccess = _a.hasAccess, redirectPath = _a.redirectPath, rest = __rest(_a, ["hasAccess", "redirectPath"]);
+            if (!hasAccess) {
+                return react_1.default.createElement(react_router_dom_1.Redirect, { to: redirectPath });
             }
             return react_1.default.createElement(WrappedComponent, __assign({}, rest));
         };
@@ -78,23 +78,39 @@ var configureActivityRequiredComponent = function (WrappedComponent) {
 exports.configureActivityRequiredComponent = configureActivityRequiredComponent;
 /**
  * Return `mapStateToProps` function. Add a `hasAccess` boolean property to the component's props
- * checking whether the user has the passed `requiredActivity`
+ * checking whether the user has the passed `requiredActivity`.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty (Optional) The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-var configureMapStateToProps = function (accessPredicate, requiredActivity, modelsProperty) { return function (state, ownProps) {
+var configureMapStateToProps = function (accessPredicate, requiredActivity, modelsProperty, redirectPath) { return function (state, ownProps) {
+    var options = baseActivity_1.defaultOptions(state, ownProps, modelsProperty);
     return {
-        hasAccess: accessPredicate(requiredActivity, baseActivity_1.defaultOptions(state, ownProps, modelsProperty))
+        hasAccess: accessPredicate(requiredActivity, options),
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
-function activityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, modelsProperty) {
+/**
+ * This HOC ensures that the wrapped component is rendered if the predicate provided is satisfied.
+ *
+ * Typically this component is used by passing one of the functions in utils/activities as the
+ * `accessPredicate` and a constant from "constants/activities" as the `requiredActivity`.
+ *
+ * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
+ * and `modelsProperty` parameters. They can be ignored if not needed by the lambda.
+ *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
+ */
+function activityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, modelsProperty, redirectPath) {
     var ActivityRequiredComponent = exports.configureActivityRequiredComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, modelsProperty);
+    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, modelsProperty, redirectPath);
     // @ts-ignore: could not match inferred type from the `connect` HOC
     return react_redux_1.connect(mapStateToProps)(ActivityRequiredComponent);
 }

package/lib/components/HOC/CollectionComponent.js

@@ -123,11 +123,11 @@ function configureCollectionComponent(WrappedComponent, LoaderComponent) {
             collection_1.initializeCollection(model, this.load, this.getCollectionMethodConfig());
         };
         CollectionComponent.prototype.componentDidUpdate = function (prevProps) {
-            var prevModel = prevProps.model, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
-            var _a = this.props, model = _a.model, pathParams = _a.pathParams, queryParams = _a.queryParams;
+            var prevModel = prevProps.model, prevModelName = prevProps.modelName, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
+            var _a = this.props, model = _a.model, modelName = _a.modelName, pathParams = _a.pathParams, queryParams = _a.queryParams;
             var fetchingId = this.state.fetchingId;
             model_1.handleModelFetchFinish(model, prevModel, fetchingId, this.changeModelStatus);
-            collection_1.handleCollectionParamsChange(pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
+            collection_1.handleCollectionParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
         };
         CollectionComponent.prototype.componentWillUnmount = function () {
             var model = this.props.model;

package/lib/components/HOC/CollectionItemComponent.js

@@ -125,10 +125,10 @@ function configureCollectionItemComponent(WrappedComponent, LoaderComponent) {
             collection_1.initializeCollectionItem(model, this.load, this.getCollectionMethodConfig());
         };
         CollectionItemComponent.prototype.componentDidUpdate = function (prevProps) {
-            var prevModel = prevProps.model, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
+            var prevModel = prevProps.model, prevModelName = prevProps.modelName, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
             var _a = this.props, modelName = _a.modelName, model = _a.model, pathParams = _a.pathParams, queryParams = _a.queryParams;
             model_1.handleModelFetchFinish(model, prevModel, undefined, this.setModelStatus);
-            collection_1.handleCollectionItemParamsChange(modelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
+            collection_1.handleCollectionItemParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
         };
         CollectionItemComponent.prototype.render = function () {
             var _a = this.props, history = _a.history, match = _a.match, location = _a.location, staticContext = _a.staticContext, otherProps = __rest(_a, ["history", "match", "location", "staticContext"]);

package/lib/components/HOC/GroupActivityRequiredComponent.d.ts

@@ -15,15 +15,18 @@ export interface GroupRelatedEntity extends Model {
  * checking whether the user has the passed `requiredActivity` for the group referenced by
  * `ownProps.model.groupId`, if any.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export declare const configureMapStateToProps: <TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
+export declare const configureMapStateToProps: <TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
 /**
  * This HOC ensures that the wrapped component is only rendered if the group referenced by
  * `props.model.groupId`, if any, satisfies the `accessPredicate` for the `requiredActivity`.
  *
- * @see ActivityRequiredComponent
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function groupActivityRequiredComponent<TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string): ComponentClass<TOwnProps>;
+export default function groupActivityRequiredComponent<TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string, redirectPath?: string | undefined | ((options: ActivityOptions) => string | undefined)): ComponentClass<TOwnProps>;

package/lib/components/HOC/GroupActivityRequiredComponent.js

@@ -20,17 +20,18 @@ var ActivityRequiredComponent_1 = require("./ActivityRequiredComponent");
  * checking whether the user has the passed `requiredActivity` for the group referenced by
  * `ownProps.model.groupId`, if any.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-var configureMapStateToProps = function (accessPredicate, requiredActivity) { return function (state, ownProps) {
+var configureMapStateToProps = function (accessPredicate, requiredActivity, redirectPath) { return function (state, ownProps) {
     var entity = ownProps && ownProps.model && state.models && state.models.groups
         ? state.models.groups[ownProps.model.groupId]
         : undefined;
     var options = __assign(__assign({}, baseActivity_1.defaultOptions(state, ownProps)), { entity: entity });
     return {
-        hasAccess: accessPredicate(requiredActivity, options)
+        hasAccess: accessPredicate(requiredActivity, options),
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
@@ -38,11 +39,14 @@ exports.configureMapStateToProps = configureMapStateToProps;
  * This HOC ensures that the wrapped component is only rendered if the group referenced by
  * `props.model.groupId`, if any, satisfies the `accessPredicate` for the `requiredActivity`.
  *
- * @see ActivityRequiredComponent
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-function groupActivityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity) {
+function groupActivityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, redirectPath) {
     var ActivityRequiredComponent = ActivityRequiredComponent_1.configureActivityRequiredComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity);
+    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, redirectPath);
     // @ts-ignore: could not match inferred type from the `connect` HOC
     return react_redux_1.connect(mapStateToProps)(ActivityRequiredComponent);
 }

package/lib/components/Quill/Formats/Image.d.ts

@@ -0,0 +1,46 @@
+declare const Parchment: {
+    Scope: typeof import("parchment/dist/src/registry").Scope;
+    create: typeof import("parchment/dist/src/registry").create;
+    find: typeof import("parchment/dist/src/registry").find;
+    query: typeof import("parchment/dist/src/registry").query;
+    register: typeof import("parchment/dist/src/registry").register;
+    Container: typeof import("parchment/dist/src/blot/abstract/container").default;
+    Format: typeof import("parchment/dist/src/blot/abstract/format").default;
+    Leaf: typeof import("parchment/dist/src/blot/abstract/leaf").default;
+    Embed: typeof import("parchment/dist/src/blot/embed").default;
+    Scroll: typeof import("parchment/dist/src/blot/scroll").default;
+    Block: typeof import("parchment/dist/src/blot/block").default;
+    Inline: typeof import("parchment/dist/src/blot/inline").default;
+    Text: typeof import("parchment/dist/src/blot/text").default;
+    Attributor: {
+        Attribute: typeof import("parchment/dist/src/attributor/attributor").default;
+        Class: typeof import("parchment/dist/src/attributor/class").default;
+        Style: typeof import("parchment/dist/src/attributor/style").default;
+        Store: typeof import("parchment/dist/src/attributor/store").default;
+    };
+};
+export interface ImageValue {
+    src: string;
+    alt: string;
+    width: string;
+    height: string;
+}
+declare type ImageBlotOnClick = (img: ImageValue, blot: Image) => void;
+export declare function setImageClickHandlersEnabled(value: boolean): void;
+export declare function setOnImageBlotClick(guid: string, value: ImageBlotOnClick | undefined): void;
+/**
+ * Defines a new implementation of `Image`, to allow setting alt text, width, and height.
+ *
+ * https://github.com/zenoamaro/react-quill/issues/169
+ */
+export declare class Image extends Parchment.Embed {
+    static blotName: string;
+    static tagName: string;
+    /** Creates the DOM Node from a value */
+    static create(value: ImageValue): HTMLImageElement;
+    /** Returns the value for a DOM Node */
+    static value(node: HTMLImageElement): ImageValue;
+    /** Create the Blot using the DOM Node from static `create` */
+    constructor(domNode: HTMLImageElement);
+}
+export {};

package/lib/components/Quill/Formats/Image.js

@@ -0,0 +1,86 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    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);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = exports.setOnImageBlotClick = exports.setImageClickHandlersEnabled = void 0;
+var react_quill_1 = require("react-quill");
+var dom_1 = require("../../../utils/dom");
+var logger_1 = require("../../../utils/logger");
+var Parchment = react_quill_1.Quill.import('parchment');
+var clickHandlersEnabled = true;
+var onClickHandlers = {};
+function setImageClickHandlersEnabled(value) {
+    clickHandlersEnabled = value;
+}
+exports.setImageClickHandlersEnabled = setImageClickHandlersEnabled;
+function setOnImageBlotClick(guid, value) {
+    if (value) {
+        onClickHandlers[guid] = value;
+    }
+    else {
+        delete onClickHandlers[guid];
+    }
+}
+exports.setOnImageBlotClick = setOnImageBlotClick;
+/**
+ * Defines a new implementation of `Image`, to allow setting alt text, width, and height.
+ *
+ * https://github.com/zenoamaro/react-quill/issues/169
+ */
+var Image = /** @class */ (function (_super) {
+    __extends(Image, _super);
+    /** Create the Blot using the DOM Node from static `create` */
+    function Image(domNode) {
+        var _this = _super.call(this, domNode) || this;
+        // right click listener to open modal to edit alt text
+        domNode.addEventListener('contextmenu', function (ev) {
+            logger_1.getLogger().debug('image right clicked', { this: _this, ev: ev });
+            var quillEdit = dom_1.getFirstParentElementWithClassName(domNode, 'QuillEdit');
+            if (!quillEdit) {
+                return;
+            }
+            var onClick = onClickHandlers[quillEdit.id];
+            if (onClick && clickHandlersEnabled) {
+                ev.preventDefault();
+                onClick(Image.value(domNode), _this);
+            }
+        });
+        return _this;
+    }
+    /** Creates the DOM Node from a value */
+    Image.create = function (value) {
+        var _a, _b, _c;
+        var node = _super.create.call(this, this.tagName);
+        // Adding a default value for images already saved in the db
+        node.setAttribute('alt', (_a = value.alt) !== null && _a !== void 0 ? _a : 'Statement Image');
+        node.setAttribute('src', value.src);
+        // Setting up the height and width to be reactive when an image is getting resize
+        node.setAttribute('height', (_b = value.height) !== null && _b !== void 0 ? _b : 'auto');
+        node.setAttribute('width', (_c = value.width) !== null && _c !== void 0 ? _c : 'auto');
+        return node;
+    };
+    /** Returns the value for a DOM Node */
+    Image.value = function (node) {
+        return {
+            width: node.getAttribute('width'),
+            height: node.getAttribute('height'),
+            alt: node.getAttribute('alt'),
+            src: node.getAttribute('src')
+        };
+    };
+    Image.blotName = 'image';
+    Image.tagName = 'IMG';
+    return Image;
+}(Parchment.Embed));
+exports.Image = Image;

package/lib/components/Quill/Formats/List.d.ts

@@ -0,0 +1,15 @@
+declare const QuillList: typeof import("parchment/dist/src/blot/abstract/container").default;
+declare const QuillListItem: typeof import("parchment/dist/src/blot/block").default;
+export declare class ListItem extends QuillListItem {
+    format(name: string, value: any): void;
+}
+/**
+ * Extend `List` to add new `alpha` type.
+ */
+export declare class List extends QuillList {
+    static allowedChildren: (typeof ListItem)[];
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): any;
+    optimize(context: any): void;
+}
+export {};

package/lib/components/Quill/Formats/List.js

@@ -0,0 +1,79 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    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);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = exports.ListItem = void 0;
+var react_quill_1 = require("react-quill");
+var logger_1 = require("../../../utils/logger");
+var constants_1 = require("../TableModule/constants");
+var QuillList = react_quill_1.Quill.import('formats/list');
+var QuillListItem = react_quill_1.Quill.import('formats/list/item');
+var ALPHA = 'alpha';
+var ListItem = /** @class */ (function (_super) {
+    __extends(ListItem, _super);
+    function ListItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ListItem.prototype.format = function (name, value) {
+        if (name === constants_1.TABLE_BLOT_NAME.TD && this.parent) {
+            logger_1.getLogger().debug('ListItem format: wrap parent in TD');
+            this.parent.wrap(name, value);
+        }
+        else {
+            _super.prototype.format.call(this, name, value);
+        }
+    };
+    return ListItem;
+}(QuillListItem));
+exports.ListItem = ListItem;
+/**
+ * Extend `List` to add new `alpha` type.
+ */
+var List = /** @class */ (function (_super) {
+    __extends(List, _super);
+    function List() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    List.create = function (value) {
+        var node = _super.create.call(this, value === ALPHA ? 'ordered' : value);
+        if (value === ALPHA) {
+            node.setAttribute('data-value', ALPHA);
+        }
+        return node;
+    };
+    List.formats = function (domNode) {
+        if (domNode.tagName === 'OL' &&
+            domNode.hasAttribute('data-value') &&
+            domNode.getAttribute('data-value') === ALPHA) {
+            return ALPHA;
+        }
+        // @ts-ignore: parent List class _does_ implement `formats`
+        return _super.formats.call(this, domNode);
+    };
+    List.prototype.optimize = function (context) {
+        var next = this.next;
+        if (next != null &&
+            next.prev === this &&
+            next instanceof QuillList &&
+            next.domNode.tagName === this.domNode.tagName &&
+            next.domNode.getAttribute('data-checked') === this.domNode.getAttribute('data-checked') &&
+            // add data-value comparison, avoid combining "ordered" and "alpha" lists
+            next.domNode.getAttribute('data-value') === this.domNode.getAttribute('data-value')) {
+            _super.prototype.optimize.call(this, context);
+        }
+    };
+    List.allowedChildren = [ListItem];
+    return List;
+}(QuillList));
+exports.List = List;

package/lib/components/Quill/Formats/Video.d.ts

@@ -0,0 +1,11 @@
+declare const QuillVideo: typeof import("parchment/dist/src/blot/embed").default;
+/**
+ * Extend `Video` to allow use inside of a `TableCellBlot`
+ */
+export declare class Video extends QuillVideo {
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+}
+export {};

package/lib/components/Quill/Formats/Video.js

@@ -0,0 +1,50 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    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);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Video = void 0;
+var react_quill_1 = require("react-quill");
+var TableCellBlot_1 = require("../TableModule/Blots/TableCellBlot");
+var constants_1 = require("../TableModule/constants");
+var QuillVideo = react_quill_1.Quill.import('formats/video');
+/**
+ * Extend `Video` to allow use inside of a `TableCellBlot`
+ */
+var Video = /** @class */ (function (_super) {
+    __extends(Video, _super);
+    function Video() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Video.prototype.formats = function () {
+        var formats = _super.prototype.formats.call(this);
+        // allow video that is wrapped in a table cell to return this "format"
+        // when the delta op for this blot is created
+        if (this.parent instanceof TableCellBlot_1.TableCellBlot) {
+            formats[constants_1.TABLE_BLOT_NAME.TD] = this.parent.dataValue();
+        }
+        return formats;
+    };
+    Video.prototype.formatAt = function (index, length, name, value) {
+        // `BlockEmbed` ignores all formatting sent to `formatAt`
+        // allow the video iframe to be wrapped in a table cell, e.g. "formatted as a table cell"
+        if (name === constants_1.TABLE_BLOT_NAME.TD) {
+            this.wrap(name, value);
+        }
+        else {
+            _super.prototype.formatAt.call(this, index, length, name, value);
+        }
+    };
+    return Video;
+}(QuillVideo));
+exports.Video = Video;

package/lib/components/{Blots → Quill/Specs}/CustomImageSpec.d.ts

@@ -9,6 +9,7 @@ import { DeleteAction, ImageSpec, ResizeAction } from 'quill-blot-formatter';
 declare class CustomImageSpec extends ImageSpec {
     init(): void;
     getActions(): (typeof ResizeAction | typeof DeleteAction)[];
-    reposition: (e: any) => void;
+    onRightClick: (e: Event) => void;
+    reposition: (_e: Event) => void;
 }
 export default CustomImageSpec;

package/lib/components/{Blots → Quill/Specs}/CustomImageSpec.js

@@ -25,7 +25,13 @@ var CustomImageSpec = /** @class */ (function (_super) {
     __extends(CustomImageSpec, _super);
     function CustomImageSpec() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.reposition = function (e) {
+        _this.onRightClick = function (e) {
+            e.preventDefault();
+            if (_this.img) {
+                _this.img.dispatchEvent(new CustomEvent('contextmenu'));
+            }
+        };
+        _this.reposition = function (_e) {
             if (_this.img) {
                 _this.formatter.repositionOverlay();
             }
@@ -34,8 +40,11 @@ var CustomImageSpec = /** @class */ (function (_super) {
     }
     CustomImageSpec.prototype.init = function () {
         _super.prototype.init.call(this);
+        // listen for scroll and resize, to reposition the overlay
         this.formatter.quill.root.addEventListener('scroll', this.reposition);
         window.addEventListener('resize', this.reposition);
+        // listen for right-click of the overlay, to pass through to the img
+        this.formatter.overlay.addEventListener('contextmenu', this.onRightClick);
     };
     CustomImageSpec.prototype.getActions = function () {
         return [quill_blot_formatter_1.ResizeAction, quill_blot_formatter_1.DeleteAction];

package/lib/components/Quill/TableModule/Blots/BaseTableBlot.d.ts

@@ -0,0 +1,29 @@
+declare const Container: typeof import("parchment/dist/src/blot/abstract/container").default;
+/**
+ * A base class for all Table module blots to inherit.
+ *
+ * Created with a `value` that is stored on the DOM Node as the `data-value` attribute.
+ * This is used for optimization (merging related blots).
+ */
+export declare class BaseTableBlot extends Container {
+    static scope: import("parchment/dist/src/registry").Scope;
+    static requiredParent: string | null;
+    static allowedChildren: (typeof import("parchment/dist/src/blot/abstract/container").default | typeof import("parchment/dist/src/blot/embed").default | {
+        new (data?: string | undefined): Text;
+        prototype: Text;
+    })[];
+    static createWithValue(tagName: string, value: string): HTMLElement;
+    /**
+     * Check if the blot only contains `<p><br></p>`
+     */
+    static containsOnlyEmptyBlock(blot: BaseTableBlot): boolean | null;
+    optimize(_context: {
+        [key: string]: any;
+    }): void;
+    unwrap(): void;
+    optimizeRemoveIfEmpty(): boolean;
+    optimizeMergeWithNext(): boolean;
+    optimizeWrapInRequiredParent(value: string): boolean;
+    dataValue(): string;
+}
+export {};