@modusoperandi/licit-vignette 0.0.18 → 1.0.0

package/{src/Constants.ts → Constants.js}

@@ -1,6 +1,6 @@
-export const VIGNETTE = 'vignette';
-export const PARAGRAPH = 'paragraph';
-export const TABLE = 'table';
-export const TABLE_CELL = 'table_cell';
-export const DEF_BORDER_COLOR = '#36598d';
-export const DEF_BORDER_RADIUS = '10px';
+export const VIGNETTE = 'vignette';
+export const PARAGRAPH = 'paragraph';
+export const TABLE = 'table';
+export const TABLE_CELL = 'table_cell';
+export const DEF_BORDER_COLOR = '#36598d';
+export const DEF_BORDER_RADIUS = '10px';

package/{dist/CreateCommand.d.ts → CreateCommand.d.ts}

@@ -3,5 +3,5 @@ import { Transform } from 'prosemirror-transform';
 import { EditorView } from 'prosemirror-view';
 import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
 type ExecuteCall = (state: EditorState, dispatch?: (tr: Transform) => void, view?: EditorView) => boolean;
-export default function createCommand(execute: ExecuteCall): UICommand;
+export declare function createCommand(execute: ExecuteCall): UICommand;
 export {};

package/CreateCommand.js

@@ -0,0 +1,36 @@
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+export function createCommand(execute) {
+    class CustomCommand extends UICommand {
+        isEnabled = (state) => {
+            return this.execute(state);
+        };
+        execute = (state, dispatch, view) => {
+            const tr = state.tr;
+            let endTr = tr;
+            execute(state, (nextTr) => {
+                endTr = nextTr;
+                dispatch?.(endTr);
+            }, view);
+            return endTr.docChanged || tr !== endTr;
+        };
+        waitForUserInput = (_state, _dispatch, _view, _event) => {
+            return Promise.resolve(undefined);
+        };
+        executeWithUserInput = (_state, _dispatch, _view, _inputs) => {
+            return false;
+        };
+        cancel() {
+            return null;
+        }
+        renderLabel() {
+            return null;
+        }
+        isActive() {
+            return true;
+        }
+        executeCustom(_state, tr) {
+            return tr;
+        }
+    }
+    return new CustomCommand();
+}

package/TableBackgroundColorCommand.d.ts

@@ -0,0 +1,4 @@
+import { TableColorCommand } from './ui/TableColorCommand';
+export declare class TableBackgroundColorCommand extends TableColorCommand {
+    getAttrName: () => string;
+}

package/TableBackgroundColorCommand.js

@@ -0,0 +1,6 @@
+import { TableColorCommand } from './ui/TableColorCommand';
+export class TableBackgroundColorCommand extends TableColorCommand {
+    getAttrName = () => {
+        return 'background';
+    };
+}

package/TableBorderColorCommand.d.ts

@@ -0,0 +1,4 @@
+import { TableColorCommand } from './ui/TableColorCommand';
+export declare class TableBorderColorCommand extends TableColorCommand {
+    getAttrName: () => string;
+}

package/TableBorderColorCommand.js

@@ -0,0 +1,6 @@
+import { TableColorCommand } from './ui/TableColorCommand';
+export class TableBorderColorCommand extends TableColorCommand {
+    getAttrName = () => {
+        return 'borderColor';
+    };
+}

package/{dist/VignetteCommand.d.ts → VignetteCommand.d.ts}

@@ -2,11 +2,18 @@ import { Schema } from 'prosemirror-model';
 import { EditorState, Transaction } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
-declare class VignetteCommand extends UICommand {
+import * as React from 'react';
+import { Transform } from 'prosemirror-transform';
+export declare class VignetteCommand extends UICommand {
     isEnabled: (state: EditorState, view?: EditorView) => boolean;
     execute: (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView) => boolean;
+    waitForUserInput: (_state: EditorState, _dispatch: (tr: Transform) => void, _view: EditorView, _event: React.SyntheticEvent<Element, Event>) => Promise<undefined>;
+    executeWithUserInput: (_state: EditorState, _dispatch: (tr: Transform) => void, _view: EditorView, _inputs: string) => boolean;
+    cancel(): void;
     __isEnabled: (_state: EditorState, _view?: EditorView) => boolean;
     insertTable(tr: Transaction, schema: Schema, rows: number, cols: number): Transaction;
     insertParagraph(state: EditorState, tr: Transaction): Transaction;
+    renderLabel(): any;
+    isActive(): boolean;
+    executeCustom(_state: EditorState, tr: Transform): Transform;
 }
-export default VignetteCommand;

package/VignetteCommand.js

@@ -0,0 +1,93 @@
+import { Fragment } from 'prosemirror-model';
+import { TextSelection } from 'prosemirror-state';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { DEF_BORDER_COLOR, PARAGRAPH, TABLE, TABLE_CELL } from './Constants';
+export class VignetteCommand extends UICommand {
+    isEnabled = (state, view) => {
+        return this.__isEnabled(state, view);
+    };
+    execute = (state, dispatch, view) => {
+        if (dispatch) {
+            const { schema } = state;
+            let { tr } = state;
+            tr = this.insertTable(tr, schema, 1, 1);
+            tr = this.insertParagraph(state, tr);
+            dispatch(tr);
+            view?.focus();
+        }
+        return true;
+    };
+    waitForUserInput = (_state, _dispatch, _view, _event) => {
+        return Promise.resolve(undefined);
+    };
+    executeWithUserInput = (_state, _dispatch, _view, _inputs) => {
+        return false;
+    };
+    cancel() {
+        return null;
+    }
+    __isEnabled = (_state, _view) => {
+        return true;
+    };
+    insertTable(tr, schema, rows, cols) {
+        if (!tr.selection || !tr.doc) {
+            return tr;
+        }
+        const { from, to } = tr.selection;
+        if (from !== to) {
+            return tr;
+        }
+        const { nodes } = schema;
+        const cell = nodes[TABLE_CELL];
+        const paragraph = nodes[PARAGRAPH];
+        const row = nodes['table_row'];
+        const table = nodes[TABLE];
+        if (!(cell && paragraph && row && table)) {
+            return tr;
+        }
+        const rowNodes = [];
+        for (let rr = 0; rr < rows; rr++) {
+            const cellNodes = [];
+            for (let cc = 0; cc < cols; cc++) {
+                // [FS] IRAD-950 2020-05-25
+                // Fix:Extra arrow key required for cell navigation using arrow right/Left
+                const cellNode = cell.create({
+                    borderColor: DEF_BORDER_COLOR,
+                    background: '#dce6f2',
+                    vignette: true,
+                }, Fragment.fromArray([paragraph.create()]));
+                cellNodes.push(cellNode);
+            }
+            const rowNode = row.create({}, Fragment.from(cellNodes));
+            rowNodes.push(rowNode);
+        }
+        const tableNode = table.create({ vignette: true }, Fragment.from(rowNodes));
+        tr = tr.insert(from, Fragment.from(tableNode));
+        const selection = TextSelection.create(tr.doc, from + 5, from + 5);
+        tr = tr.setSelection(selection);
+        return tr;
+    }
+    // [FS] 2021-04-01
+    // Add empty line after table drop
+    // To make easier to enter a line after table
+    insertParagraph(state, tr) {
+        const paragraph = state.schema.nodes[PARAGRAPH];
+        const textNode = state.schema.text(' ');
+        const { from, to } = tr.selection;
+        if (from !== to) {
+            return tr;
+        }
+        const paragraphNode = paragraph.create({}, textNode, null);
+        tr = tr.insert(from + tr.selection.$head.node(1).nodeSize - 4, Fragment.from(paragraphNode));
+        return tr;
+    }
+    renderLabel() {
+        return null;
+    }
+    isActive() {
+        return true;
+    }
+    executeCustom(_state, tr) {
+        return tr;
+    }
+}

package/VignetteMenuPlugin.d.ts

@@ -0,0 +1,24 @@
+import { EditorState, Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { TableView } from 'prosemirror-tables';
+export declare class VignetteView {
+    constructor(editorView: EditorView);
+    setCustomMenu(editorView: EditorView): void;
+    setCustomTableNodeViewUpdate(editorView: EditorView): void;
+    tableNodeViewEx(tableNodeView: (node: Node, view: EditorView) => TableView, node: Node, view: EditorView): TableView;
+    updateEx(update: (node: Node) => boolean, self: VignetteView, node: Node): boolean;
+    updateBorder(tableView: TableView): void;
+    static isVignette(state: EditorState, actionNode: Node): boolean;
+    getMenu(state: EditorState, actionNode: Node, cmdGrps: Array<{
+        [key: string]: UICommand;
+    }>): Array<{
+        [key: string]: UICommand;
+    }>;
+    isEnabledEx(isEnabled: (state: EditorState, view?: EditorView) => boolean, state: EditorState, view?: EditorView): boolean;
+    destroy: () => void;
+}
+export declare class VignetteMenuPlugin extends Plugin {
+    constructor();
+}

package/VignetteMenuPlugin.js

@@ -0,0 +1,112 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { TableBackgroundColorCommand } from './TableBackgroundColorCommand';
+import { TableBorderColorCommand } from './TableBorderColorCommand';
+import { createCommand } from './CreateCommand';
+import { CellSelection, deleteTable } from 'prosemirror-tables';
+import { TABLE } from './Constants';
+const TABLE_BACKGROUND_COLOR = new TableBackgroundColorCommand();
+const TABLE_BORDER_COLOR = new TableBorderColorCommand();
+const TABLE_DELETE_TABLE = createCommand(deleteTable);
+const VIGNETTE_COMMANDS_GROUP = [
+    {
+        'Fill Color...': TABLE_BACKGROUND_COLOR,
+        'Border Color....': TABLE_BORDER_COLOR,
+    },
+    {
+        'Delete Vignette': TABLE_DELETE_TABLE,
+    },
+];
+export class VignetteView {
+    constructor(editorView) {
+        this.setCustomMenu(editorView);
+        this.setCustomTableNodeViewUpdate(editorView);
+    }
+    setCustomMenu(editorView) {
+        editorView['pluginViews'].forEach((pluginView) => {
+            if (
+            // 'TableCellTooltipView' has property _cellElement
+            Object.hasOwn(pluginView, '_cellElement')) {
+                pluginView['getMenu'] = this.getMenu.bind(this);
+            }
+        });
+    }
+    setCustomTableNodeViewUpdate(editorView) {
+        const tableNodeView = editorView['nodeViews']['table'];
+        const tableNodeViewEx = this.tableNodeViewEx.bind(this, tableNodeView);
+        editorView['nodeViews'][TABLE] = tableNodeViewEx;
+        const index = editorView.state.plugins.findIndex((plugin) => {
+            let found = false;
+            if (plugin.spec.key) {
+                found = plugin.spec.key['key'].includes('tableColumnResizing$');
+            }
+            return found;
+        });
+        if (-1 != index) {
+            editorView.state.plugins[index].spec.props.nodeViews[TABLE] =
+                tableNodeViewEx;
+        }
+    }
+    tableNodeViewEx(tableNodeView, node, view) {
+        const base = tableNodeView?.(node, view);
+        if (base?.update && node.attrs.vignette) {
+            base.update = this.updateEx.bind(base, base.update, this);
+            this.updateBorder(base);
+        }
+        return base;
+    }
+    updateEx(update, self, node) {
+        const result = update.call(this, node);
+        if (result) {
+            self.updateBorder(this);
+        }
+        return result;
+    }
+    updateBorder(tableView) {
+        if (tableView.table) {
+            tableView.table.style.border = 'none';
+        }
+    }
+    static isVignette(state, actionNode) {
+        let vignette = false;
+        if (state.selection instanceof CellSelection) {
+            if (state.selection.$anchorCell.node(-1).attrs.vignette) {
+                vignette = true;
+            }
+        }
+        if (actionNode?.attrs.vignette) {
+            vignette = true;
+        }
+        if (state.selection.$anchor.node(1).attrs.vignette) {
+            vignette = true;
+        }
+        return vignette;
+    }
+    getMenu(state, actionNode, cmdGrps) {
+        const vignette = VignetteView.isVignette(state, actionNode);
+        cmdGrps.forEach((cmdGrp) => {
+            Object.entries(cmdGrp).forEach((entry) => {
+                entry[1].isEnabled = this.isEnabledEx.bind(entry[1], entry[1].isEnabled);
+            });
+        });
+        return vignette ? VIGNETTE_COMMANDS_GROUP : cmdGrps;
+    }
+    isEnabledEx(isEnabled, state, view) {
+        return VignetteView.isVignette(state, null)
+            ? false
+            : isEnabled.call(this, state, view);
+    }
+    destroy = () => {
+        // do nothing.
+    };
+}
+const SPEC = {
+    key: new PluginKey('VignetteMenuPlugin'),
+    view(editorView) {
+        return new VignetteView(editorView);
+    },
+};
+export class VignetteMenuPlugin extends Plugin {
+    constructor() {
+        super(SPEC);
+    }
+}

package/{dist/VignetteNodeSpec.d.ts → VignetteNodeSpec.d.ts}

@@ -1,3 +1,3 @@
-export declare const VignetteTableNodeSpec: (nodespec: NodeSpec) => any;
-export declare const VignetteTableCellNodeSpec: (nodespec: NodeSpec) => any;
-export default VignetteTableNodeSpec;
+import { NodeSpec } from 'prosemirror-model';
+export declare const VignetteTableNodeSpec: (nodespec: NodeSpec) => NodeSpec;
+export declare const VignetteTableCellNodeSpec: (nodespec: NodeSpec) => NodeSpec;

package/VignetteNodeSpec.js

@@ -0,0 +1,67 @@
+import { TABLE, VIGNETTE } from './Constants';
+// Override the default table node spec to support custom attributes.
+export const VignetteTableNodeSpec = (nodespec) => ({
+    ...nodespec,
+    attrs: {
+        marginLeft: { default: null },
+        vignette: { default: false },
+    },
+    parseDOM: [
+        {
+            tag: TABLE,
+            getAttrs(dom) {
+                const { marginLeft } = dom.style;
+                const vignette = dom.getAttribute(VIGNETTE) === 'true' || false;
+                const marginAmount = parseFloat(marginLeft);
+                if (marginLeft &&
+                    !Number.isNaN(marginAmount) &&
+                    marginLeft.includes('px')) {
+                    return { marginLeft: marginAmount, vignette };
+                }
+                return { vignette };
+            },
+            style: 'border',
+        },
+    ],
+    toDOM(node) {
+        // Normally, the DOM structure of the table node is rendered by
+        // `TableNodeView`. This method is only called when user selects a
+        // table node and copies it, which triggers the "serialize to HTML" flow
+        //  that calles this method.
+        const { marginLeft, vignette } = node.attrs;
+        const domAttrs = { vignette };
+        let style = 'border: none';
+        if (marginLeft) {
+            style += `margin-left: ${marginLeft}px`;
+        }
+        domAttrs['style'] = style;
+        return [TABLE, domAttrs, 0];
+    },
+});
+export const VignetteTableCellNodeSpec = (nodespec) => ({
+    ...nodespec,
+    attrs: { ...nodespec.attrs, vignette: { default: false } },
+    parseDOM: [
+        {
+            tag: 'td',
+            getAttrs: (dom) => {
+                return {
+                    ...nodespec.parseDOM[0].getAttrs(dom),
+                    vignette: dom.getAttribute(VIGNETTE) === 'true' || false,
+                };
+            },
+        },
+    ],
+    toDOM(node) {
+        const base = nodespec.toDOM(node);
+        if (node.attrs.vignette &&
+            Array.isArray(base) &&
+            1 < base.length &&
+            base[1].style) {
+            base[1].style +=
+                'border-radius: 10px; border-style: solid; border-width: thin';
+        }
+        base[1].vignette = node.attrs.vignette;
+        return base;
+    },
+});

package/{dist/VignettePlugin.d.ts → VignettePlugin.d.ts}

@@ -1,7 +1,7 @@
 import { Plugin } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 import { Schema } from 'prosemirror-model';
-import VignetteCommand from './VignetteCommand';
+import { VignetteCommand } from './VignetteCommand';
 export declare class VignettePlugin extends Plugin {
     _view: EditorView;
     constructor();

package/VignettePlugin.js

@@ -0,0 +1,39 @@
+// Plugin to handle Citation.
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Schema } from 'prosemirror-model';
+import { VignetteCommand } from './VignetteCommand';
+import { VignetteTableCellNodeSpec, VignetteTableNodeSpec, } from './VignetteNodeSpec';
+import { TABLE, TABLE_CELL } from './Constants';
+export class VignettePlugin extends Plugin {
+    _view = null;
+    constructor() {
+        super({
+            key: new PluginKey('VignettePlugin'),
+            state: {
+                init(_config, _state) {
+                    // do nothing
+                },
+                apply(_tr, _set) {
+                    //do nothing
+                },
+            },
+            props: {
+                nodeViews: {},
+            },
+        });
+    }
+    getEffectiveSchema(schema) {
+        let nodes = schema.spec.nodes.update(TABLE, VignetteTableNodeSpec(schema.spec.nodes.get(TABLE)));
+        nodes = nodes.update(TABLE_CELL, VignetteTableCellNodeSpec(schema.spec.nodes.get(TABLE_CELL)));
+        const marks = schema.spec.marks;
+        return new Schema({
+            nodes: nodes,
+            marks: marks,
+        });
+    }
+    initButtonCommands() {
+        return {
+            '[crop] Insert Vignette': new VignetteCommand(),
+        };
+    }
+}

package/VignettePlugins.d.ts

@@ -0,0 +1,3 @@
+import { VignettePlugin } from './VignettePlugin';
+import { VignetteMenuPlugin } from './VignetteMenuPlugin';
+export declare const VignettePlugins: (VignetteMenuPlugin | VignettePlugin)[];

package/VignettePlugins.js

@@ -0,0 +1,6 @@
+import { VignettePlugin } from './VignettePlugin';
+import { VignetteMenuPlugin } from './VignetteMenuPlugin';
+export const VignettePlugins = [
+    new VignetteMenuPlugin(),
+    new VignettePlugin(),
+];

package/index.d.ts

@@ -0,0 +1,10 @@
+export * from './VignettePlugins';
+export * from './ui/TableColorCommand';
+export * from './CreateCommand';
+export * from './TableBackgroundColorCommand';
+export * from './TableBorderColorCommand';
+export * from './VignetteCommand';
+export * from './VignettePlugin';
+export * from './Constants';
+export * from './VignetteMenuPlugin';
+export * from './VignetteNodeSpec';

package/index.js

@@ -0,0 +1,10 @@
+export * from './VignettePlugins';
+export * from './ui/TableColorCommand';
+export * from './CreateCommand';
+export * from './TableBackgroundColorCommand';
+export * from './TableBorderColorCommand';
+export * from './VignetteCommand';
+export * from './VignettePlugin';
+export * from './Constants';
+export * from './VignetteMenuPlugin';
+export * from './VignetteNodeSpec';

package/package.json

@@ -1,111 +1,72 @@
 {
   "name": "@modusoperandi/licit-vignette",
-  "version": "0.0.18",
+  "version": "1.0.0",
+  "type": "module",
   "subversion": "1",
   "description": "Vignette plugin built with ProseMirror",
-  "main": "dist/index.js",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "style": "styles.css",
   "repository": {
     "type": "git",
     "url": ""
   },
-  "bundleDependencies": [],
   "scripts": {
-    "clean": "rm -rf dist/ coverage/ bin/ && rm -f modusoperandi-licit-vignette-*.*.*.tgz",
-    "build:ts": "tsc -p tsconfig.json",
-    "build:babel": "babel src --out-dir dist --extensions .ts,.tsx",
-    "build:dist": "npm run clean && npm run build:ts && npm run webpack && npm run build:babel && npm run build:css",
-    "webpack": "webpack",
-    "build:css": "echo 'no CSS files available'",
+    "clean": "rm -rf dist/ bin/ && rm -f modusoperandi-licit-vignette-*.*.*.tgz",
     "lint:ts": "eslint src --ext .ts,.tsx --fix",
     "lint:css": "echo 'no CSS files available'",
     "lint": "npm run lint:css & npm run lint:ts",
-    "ci:build": "npm run clean && npm run build:ts && npm run webpack && npm run build:babel && npm run build:css",
     "test:unit": "jest",
     "test:coverage": "jest --coverage",
-    "prepare": "npm run build:dist",
     "test": "jest --coverage",
     "debug": "node --debug-brk --inspect ./node_modules/.bin/jest -i",
-    "ci:bom": "cyclonedx-bom -o dist/bom.xml",
-    "publish:dist": "npm publish"
+    "ci:bom": "cyclonedx-npm --ignore-npm-errors --short-PURLs --output-format XML --output-file dist/bom.xml",
+    "ci:build": "tsc --build && copyfiles --up 1 \"src/**/*.css\" dist  && copyfiles package.json dist"
+  },
+  "peerDependencies": {
+    "@modusoperandi/licit-ui-commands": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.19.3",
-    "@babel/core": "^7.19.3",
-    "@babel/eslint-parser": "^7.19.1",
-    "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/plugin-proposal-decorators": "^7.19.3",
-    "@babel/plugin-proposal-do-expressions": "^7.18.6",
-    "@babel/plugin-proposal-export-default-from": "^7.18.10",
-    "@babel/plugin-proposal-export-namespace-from": "^7.18.9",
-    "@babel/plugin-proposal-function-sent": "^7.18.6",
-    "@babel/plugin-proposal-logical-assignment-operators": "^7.18.9",
-    "@babel/plugin-proposal-object-rest-spread": "^7.19.4",
-    "@babel/plugin-proposal-pipeline-operator": "^7.18.9",
-    "@babel/plugin-proposal-throw-expressions": "^7.18.6",
-    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-syntax-import-meta": "^7.10.4",
-    "@babel/plugin-transform-parameters": "^7.18.8",
-    "@babel/plugin-transform-runtime": "^7.19.1",
-    "@babel/plugin-transform-typescript": "^7.19.3",
-    "@babel/preset-env": "^7.19.4",
-    "@babel/preset-react": "^7.18.6",
-    "@babel/preset-typescript": "^7.18.6",
-    "@cyclonedx/bom": "^3.0.3",
+    "@cyclonedx/cyclonedx-npm": "^1.11.0",
     "@testing-library/dom": "^8.19.0",
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^13.4.0",
     "@testing-library/user-event": "^14.4.3",
-    "@types/jest": "^29.1.2",
+    "@types/jest": "^29.2.0",
     "@types/node": "^18.11.0",
-    "@typescript-eslint/eslint-plugin": "^5.40.1",
-    "@typescript-eslint/parser": "^5.40.1",
-    "babel-eslint": "^10.1.0",
-    "babel-jest": "^29.2.0",
-    "babel-loader": "8.2.5",
-    "babel-plugin-transform-react-remove-prop-types": "0.4.24",
-    "clean-webpack-plugin": "^4.0.0",
-    "copy-webpack-plugin": "^11.0.0",
-    "css-loader": "^6.7.1",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.41.0",
+    "ajv": "^7.2.4",
+    "copyfiles": "^2.4.1",
     "enzyme": "^3.11.0",
-    "eslint": "8.25.0",
+    "eslint": "^8.26.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^27.1.2",
+    "eslint-plugin-jest": "^27.1.3",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-react": "7.31.10",
-    "file-loader": "^6.2.0",
+    "eslint-plugin-react": "^7.31.10",
     "husky": "^8.0.1",
     "identity-obj-proxy": "^3.0.0",
-    "jest": "^29.2.0",
-    "jest-environment-jsdom": "^29.2.0",
+    "jest": "^29.2.2",
+    "jest-environment-jsdom": "^29.2.2",
     "jest-json": "^2.0.0",
-    "jest-junit": "^14.0.1",
-    "jest-prosemirror": "^2.0.6",
+    "jest-junit": "^15.0.0",
+    "jest-prosemirror": "^2.0.0",
     "jest-sonar-reporter": "^2.0.0",
     "lint-staged": "^13.0.3",
-    "prettier": "^2.7.1",
+    "prettier": "^3.2.0",
     "react-test-renderer": "^18.2.0",
     "resize-observer-polyfill": "^1.5.1",
-    "style-loader": "^3.3.1",
-    "stylelint": "^14.14.0",
-    "stylelint-config-standard": "^29.0.0",
+    "stylelint": "^16.2.0",
+    "stylelint-config-standard": "^36.0.0",
     "stylelint-prettier": "^2.0.0",
-    "terser-webpack-plugin": "^5.3.6",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "typescript": "^4.8.4",
-    "url": "^0.11.0",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
-    "write-file-webpack-plugin": "^4.5.1"
+    "url": "^0.11.0"
   },
-  "dependencies": {
-    "@modusoperandi/licit-ui-commands": "^0.1.16",
-    "@types/node": "^16.10.1",
-    "axios": "^1.1.3",
-    "orderedmap": "^1.1.8",
-    "prop-types": "^15.8.1",
-    "rewire": "^6.0.0"
+  "overrides": {
+    "semver": "^7.5.2"
   },
   "importSort": {
     ".js": {
@@ -129,4 +90,4 @@
       "prettier --write"
     ]
   }
-}
+}