@modusoperandi/licit 0.14.18 → 1.0.0

package/client/Licit.test.js

@@ -0,0 +1,104 @@
+import React from 'react';
+import { configure, shallow } from 'enzyme';
+import Adapter from '@cfaester/enzyme-adapter-react-18';
+import Licit, { DataType } from './Licit';
+import RichTextEditor from '../ui/RichTextEditor';
+import { noop } from '@modusoperandi/licit-ui-commands';
+
+/**
+ * Configure Jest to use react / enzyme
+ */
+configure({
+  adapter: new Adapter()
+});
+describe('<Licit />', function () {
+  var wrapper;
+  var licit;
+
+  // provide an empty document just to shut up that warning
+  var data = {
+    type: 'doc',
+    content: [{
+      type: 'paragraph',
+      content: [{
+        type: 'text',
+        text: ' '
+      }]
+    }]
+  };
+
+  // Mocking the functions used in _onReady
+  var fakeEditorView = {
+    focus: noop,
+    dispatch: noop,
+    state: {
+      doc: {
+        content: {
+          size: 10
+        },
+        resolve: function resolve() {
+          return {
+            min: function min() {
+              return 0;
+            },
+            max: function max() {
+              return 10;
+            },
+            parent: {
+              inlineContent: true
+            }
+          };
+        },
+        toJSON: function toJSON() {
+          return data;
+        }
+      },
+      tr: {
+        setSelection: function setSelection() {
+          return fakeEditorView.state.tr;
+        },
+        scrollIntoView: noop
+      }
+    }
+  };
+  beforeEach(function () {
+    wrapper = shallow( /*#__PURE__*/React.createElement(Licit, {
+      data: data
+    }));
+    licit = wrapper.instance();
+  });
+  it('should render a <RichTextEditor /> ', function () {
+    expect(wrapper.find(RichTextEditor)).toBeTruthy();
+  });
+  describe('editorView (getter)', function () {
+    it('should return the prosemirror view', function () {
+      // Using shallow, the underlying RichTexEditor is never really created,
+      // and Licit's _onReady method is not called.  Call it here with the fake
+      // view created above
+      licit._onReady(fakeEditorView);
+
+      // Verify that getter now returns the underlying view.
+      expect(licit.editorView).toBe(fakeEditorView);
+    });
+  });
+});
+describe('<Licit with HTML input/>', function () {
+  var wrapper;
+  var licit;
+  var HELLO = 'Hello ';
+  var WORLD = 'World';
+  var data = '<p stylename="None">' + HELLO + '<strong overridden="false">' + WORLD + '</strong></p>';
+  beforeEach(function () {
+    wrapper = shallow( /*#__PURE__*/React.createElement(Licit, {
+      data: data,
+      dataType: DataType.HTML
+    }));
+    licit = wrapper.instance();
+  });
+  it('should render a <RichTextEditor /> ', function () {
+    expect(wrapper.find(RichTextEditor)).toBeTruthy();
+  });
+  it('should match state text content with the passed in text ', function () {
+    expect(licit.state.editorState.doc.textContent).toBe(HELLO + WORLD);
+  });
+});

package/client/Licit.test.js.flow

@@ -0,0 +1,98 @@
+import React from 'react';
+import { configure, shallow } from 'enzyme';
+import Adapter from '@cfaester/enzyme-adapter-react-18';
+import Licit, { DataType } from './Licit';
+import RichTextEditor from '../ui/RichTextEditor';
+import { noop } from '@modusoperandi/licit-ui-commands';
+
+/**
+ * Configure Jest to use react / enzyme
+ */
+configure({
+  adapter: new Adapter(),
+});
+
+describe('<Licit />', () => {
+  let wrapper;
+  let licit;
+
+  // provide an empty document just to shut up that warning
+  const data = {
+    type: 'doc',
+    content: [
+      {
+        type: 'paragraph',
+        content: [{ type: 'text', text: ' ' }],
+      },
+    ],
+  };
+
+  // Mocking the functions used in _onReady
+  const fakeEditorView = {
+    focus: noop,
+    dispatch: noop,
+    state: {
+      doc: {
+        content: { size: 10 },
+        resolve: () => ({
+          min: () => 0,
+          max: () => 10,
+          parent: { inlineContent: true },
+        }),
+        toJSON: () => data,
+      },
+      tr: {
+        setSelection: () => fakeEditorView.state.tr,
+        scrollIntoView: noop,
+      },
+    },
+  };
+
+  beforeEach(() => {
+    wrapper = shallow(<Licit data={data} />);
+    licit = wrapper.instance();
+  });
+
+  it('should render a <RichTextEditor /> ', () => {
+    expect(wrapper.find(RichTextEditor)).toBeTruthy();
+  });
+
+  describe('editorView (getter)', () => {
+    it('should return the prosemirror view', () => {
+      // Using shallow, the underlying RichTexEditor is never really created,
+      // and Licit's _onReady method is not called.  Call it here with the fake
+      // view created above
+      licit._onReady(fakeEditorView);
+
+      // Verify that getter now returns the underlying view.
+      expect(licit.editorView).toBe(fakeEditorView);
+    });
+  });
+});
+
+describe('<Licit with HTML input/>', () => {
+  let wrapper;
+  let licit;
+
+  const HELLO = 'Hello ';
+  const WORLD = 'World';
+  const data =
+    '<p stylename="None">' +
+    HELLO +
+    '<strong overridden="false">' +
+    WORLD +
+    '</strong></p>';
+
+  beforeEach(() => {
+    wrapper = shallow(<Licit data={data} dataType={DataType.HTML} />);
+    licit = wrapper.instance();
+  });
+
+  it('should render a <RichTextEditor /> ', () => {
+    expect(wrapper.find(RichTextEditor)).toBeTruthy();
+  });
+
+  it('should match state text content with the passed in text ', () => {
+    expect(licit.state.editorState.doc.textContent).toBe(HELLO + WORLD);
+  });
+});

package/client/Reporter.js

@@ -0,0 +1,50 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* eslint-disable */
+var Reporter = /*#__PURE__*/function () {
+  function Reporter() {
+    _classCallCheck(this, Reporter);
+    this.setAt = 0;
+  }
+  _createClass(Reporter, [{
+    key: "clearState",
+    value: function clearState() {
+      if (this.state) {
+        this.state = this.node = null;
+        this.setAt = 0;
+      }
+    }
+  }, {
+    key: "failure",
+    value: function failure(err) {
+      console.error('fail', err.toString());
+    }
+  }, {
+    key: "delay",
+    value: function delay(err) {
+      if (this.state == 'fail') return;
+      console.info('delay', err.toString());
+    }
+  }, {
+    key: "show",
+    value: function show(type, message) {
+      this.clearState();
+      this.state = type;
+      this.setAt = Date.now();
+    }
+  }, {
+    key: "success",
+    value: function success() {
+      var _this = this;
+      if (this.state == 'fail' && this.setAt > Date.now() - 1000 * 10) setTimeout(function () {
+        return _this.success();
+      }, 5000);else this.clearState();
+    }
+  }]);
+  return Reporter;
+}();
+export default Reporter;

package/client/SimpleConnector.js

@@ -0,0 +1,55 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { Schema } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import ReactDOM from 'react-dom';
+var bpfrpt_proptype_SetStateCall = PropTypes.func;
+var SimpleConnector = /*#__PURE__*/_createClass(function SimpleConnector(_editorState, setState) {
+  var _this = this;
+  _classCallCheck(this, SimpleConnector);
+  _defineProperty(this, "_setState", void 0);
+  _defineProperty(this, "_editorState", void 0);
+  // This flag is used to deteremine if data passed in or not
+  // If not passed in, use the data from collab server when in collab mode.
+  // else use empty content.
+  _defineProperty(this, "_dataDefined", void 0);
+  _defineProperty(this, "onEdit", function (transaction, view) {
+    ReactDOM.unstable_batchedUpdates(function () {
+      var editorState = _this._editorState.apply(transaction);
+      // [FS] IRAD-1236 2020-03-05
+      // The state property should not be directly mutated. Use the updateState method.
+      if (view) {
+        view.updateState(editorState);
+      }
+      var state = {
+        editorState: editorState,
+        data: transaction.doc.toJSON()
+      };
+      _this._setState(state, function () {
+        _this._editorState = editorState;
+      });
+    });
+  });
+  // FS IRAD-989 2020-18-06
+  // updating properties should automatically render the changes
+  _defineProperty(this, "getState", function () {
+    return _this._editorState;
+  });
+  // FS IRAD-1040 2020-09-02
+  // Send the modified schema to server
+  _defineProperty(this, "updateSchema", function (schema, data) {});
+  _defineProperty(this, "updateContent", function (data) {});
+  _defineProperty(this, "cleanUp", function () {});
+  this._editorState = _editorState;
+  this._setState = setState;
+});
+export default SimpleConnector;
+import PropTypes from "prop-types";
+export { bpfrpt_proptype_SetStateCall };

package/client/http.js

@@ -0,0 +1,90 @@
+/* eslint-disable */
+
+// A simple wrapper for XHR.
+export function req(conf) {
+  var req = new XMLHttpRequest(),
+    aborted = false;
+  var result = new Promise(function (success, failure) {
+    req.open(conf.method, conf.url, true);
+    req.addEventListener('load', function () {
+      if (aborted) return;
+      if (req.status < 400) {
+        success(req.responseText);
+      } else {
+        var text = req.responseText;
+        if (text && /html/.test(req.getResponseHeader('content-type'))) text = makePlain(text);
+        var err = new Error('Request failed: ' + req.statusText + (text ? '\n\n' + text : ''));
+        err.status = req.status;
+        failure(err);
+      }
+    });
+    req.addEventListener('error', function () {
+      if (!aborted) failure(new Error('Network error'));
+    });
+    if (conf.headers) for (var header in conf.headers) req.setRequestHeader(header, conf.headers[header]);
+    req.send(conf.body || null);
+  });
+  result.abort = function () {
+    if (!aborted) {
+      req.abort();
+      aborted = true;
+    }
+  };
+  return result;
+}
+function makePlain(html) {
+  var elt = document.createElement('div');
+  elt.innerHTML = html;
+  return elt.textContent.replace(/\n[^]*|\s+$/g, '');
+}
+export function GET(url) {
+  return req({
+    url: url,
+    method: 'GET'
+  });
+}
+export function POST(url, body, type) {
+  return req({
+    url: url,
+    method: 'POST',
+    body: body,
+    headers: {
+      'Content-Type': type
+    }
+  });
+}
+export function PUT(url, body, type) {
+  return req({
+    url: url,
+    method: 'PUT',
+    body: body,
+    headers: {
+      'Content-Type': type
+    }
+  });
+}
+
+// [FS] IRAD-1128 2021-02-03
+// http DELETE request overrided
+export function DELETE(url, type) {
+  return req({
+    url: url,
+    method: 'DELETE',
+    headers: {
+      'Content-Type': type
+    }
+  });
+}
+
+// [FS] IRAD-1128 2021-02-03
+// http PATCH request overrided
+export function PATCH(url, body, type) {
+  return req({
+    url: url,
+    method: 'PATCH',
+    body: body,
+    headers: {
+      'Content-Type': type
+    }
+  });
+}

package/client/throttle.js

@@ -0,0 +1,20 @@
+export default function throttle(fn, threshhold, context) {
+  var last;
+  var deferTimer;
+  var boundFn = fn.bind(context);
+  return function () {
+    var now = Date.now();
+    var args = Array.prototype.slice.call(arguments);
+    if (last && now < last + threshhold) {
+      // hold on to it
+      clearTimeout(deferTimer);
+      deferTimer = setTimeout(function () {
+        last = now;
+        boundFn.apply(null, args);
+      }, threshhold);
+    } else {
+      last = now;
+      boundFn.apply(null, args);
+    }
+  };
+}

package/convertFromDOMElement.js

@@ -0,0 +1,26 @@
+import { Schema } from 'prosemirror-model';
+import { DOMParser } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import { getAttrs } from './DocNodeSpec.js';
+import EditorPlugins from './EditorPlugins.js';
+import EditorSchema from './EditorSchema.js';
+export default function convertFromDOMElement(el, schema, plugins) {
+  var effectiveSchema = schema || EditorSchema;
+  var effectivePlugins = plugins || EditorPlugins;
+  var bodyEl = el.querySelector('body');
+
+  // https://prosemirror.net/docs/ref/#model.ParseOptions.preserveWhitespace
+  var doc = DOMParser.fromSchema(effectiveSchema).parse(el, {
+    preserveWhitespace: true
+  });
+  if (bodyEl) {
+    // Unfortunately the root node `doc` does not supoort `parseDOM`, thus
+    // we'd have to assign its `attrs` manually.
+    doc.attrs = getAttrs(bodyEl);
+  }
+  return EditorState.create({
+    doc: doc,
+    plugins: effectivePlugins
+  });
+}

package/convertFromDOMElement.js.flow

@@ -0,0 +1,36 @@
+// @flow
+
+import { Schema } from 'prosemirror-model';
+import { DOMParser } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+
+import { getAttrs } from './DocNodeSpec.js';
+import EditorPlugins from './EditorPlugins.js';
+import EditorSchema from './EditorSchema.js';
+
+export default function convertFromDOMElement(
+  el: HTMLElement,
+  schema: Schema,
+  plugins: Array<Plugin>
+): EditorState {
+  const effectiveSchema = schema || EditorSchema;
+  const effectivePlugins = plugins || EditorPlugins;
+  const bodyEl = el.querySelector('body');
+
+  // https://prosemirror.net/docs/ref/#model.ParseOptions.preserveWhitespace
+  const doc = DOMParser.fromSchema(effectiveSchema).parse(el, {
+    preserveWhitespace: true,
+  });
+
+  if (bodyEl) {
+    // Unfortunately the root node `doc` does not supoort `parseDOM`, thus
+    // we'd have to assign its `attrs` manually.
+    doc.attrs = getAttrs(bodyEl);
+  }
+
+  return EditorState.create({
+    doc,
+    plugins: effectivePlugins,
+  });
+}

package/convertFromHTML.js

@@ -0,0 +1,9 @@
+import { Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import convertFromDOMElement from './convertFromDOMElement.js';
+export default function convertFromHTML(html, schema, plugins) {
+  var root = document.createElement('html');
+  root.innerHTML = html ? html : ' ';
+  return convertFromDOMElement(root, schema, plugins);
+}

package/convertFromHTML.js.flow

@@ -0,0 +1,17 @@
+// @flow
+
+import { Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+
+import convertFromDOMElement from './convertFromDOMElement.js';
+
+export default function convertFromHTML(
+  html: string,
+  schema: Schema,
+  plugins: Array<Plugin>
+): EditorState {
+  const root = document.createElement('html');
+  root.innerHTML = html ? html : ' ';
+  return convertFromDOMElement(root, schema, plugins);
+}

package/convertFromJSON.js

@@ -0,0 +1,40 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import createEmptyEditorState from './createEmptyEditorState.js';
+export default function convertFromJSON(json, schema, defaultSchema, effectivePlugins) {
+  var editorSchema = schema || defaultSchema;
+  var error = false;
+  if (typeof json === 'string') {
+    try {
+      json = JSON.parse(json);
+    } catch (ex) {
+      console.error('convertFromJSON:', ex);
+      error = true;
+    }
+  }
+  if (!json || _typeof(json) !== 'object') {
+    console.error('convertFromJSON: invalid object', json);
+    error = true;
+  }
+  if (error) {
+    // [FS] IRAD-1455 2021-06-16
+    // Use the effectivePlugins, editor hangs, b'coz of missing default core plugins
+    return createEmptyEditorState(schema, defaultSchema, effectivePlugins);
+  }
+
+  // [FS] IRAD-1067 2020-09-19
+  // Handle gracefully when error thrown on invalid json
+  var doc = null;
+  try {
+    doc = editorSchema.nodeFromJSON(json);
+  } catch (error) {
+    return null;
+  }
+  return EditorState.create({
+    doc: doc,
+    schema: editorSchema,
+    plugins: effectivePlugins
+  });
+}

package/convertFromJSON.js.flow

@@ -0,0 +1,56 @@
+// @flow
+
+import { Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import createEmptyEditorState from './createEmptyEditorState.js';
+
+export default function convertFromJSON(
+  json: Object | string,
+  schema: ?Schema,
+  defaultSchema: Schema,
+  effectivePlugins: Array<Plugin>
+): EditorState {
+  const editorSchema = schema || defaultSchema;
+  let error = false;
+
+  if (typeof json === 'string') {
+    try {
+      json = JSON.parse(json);
+    } catch (ex) {
+      console.error('convertFromJSON:', ex);
+      error = true;
+    }
+  }
+
+  if (!json || typeof json !== 'object') {
+    console.error('convertFromJSON: invalid object', json);
+    error = true;
+  }
+
+  if(error) {
+    // [FS] IRAD-1455 2021-06-16
+    // Use the effectivePlugins, editor hangs, b'coz of missing default core plugins
+    return createEmptyEditorState(
+      schema,
+      defaultSchema,
+      effectivePlugins
+    );
+  }
+
+  // [FS] IRAD-1067 2020-09-19
+  // Handle gracefully when error thrown on invalid json
+  let doc = null;
+
+  try {
+    doc = editorSchema.nodeFromJSON(json);
+  } catch (error) {
+    return null;
+  }
+
+  return EditorState.create({
+    doc: doc,
+    schema: editorSchema,
+    plugins: effectivePlugins,
+  });
+}

package/convertToCSSPTValue.js

@@ -0,0 +1,18 @@
+var SIZE_PATTERN = /([\d\.]+)(px|pt)/i;
+export var PX_TO_PT_RATIO = 0.75292857;
+export var PT_TO_PX_RATIO = 1 / PX_TO_PT_RATIO;
+export default function convertToCSSPTValue(styleValue) {
+  var matches = styleValue.match(SIZE_PATTERN);
+  if (!matches) {
+    return 0;
+  }
+  var value = parseFloat(matches[1]);
+  var unit = matches[2];
+  if (!value || !unit) {
+    return 0;
+  }
+  if (unit === 'px') {
+    value = PX_TO_PT_RATIO * value;
+  }
+  return value;
+}

package/convertToJSON.js

@@ -0,0 +1,4 @@
+import { EditorState } from 'prosemirror-state';
+export default function convertToJSON(editorState) {
+  return editorState.doc.toJSON();
+}