@atlaskit/embedded-document 0.7.29

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { default as EmbeddedDocument } from './context/embedded-document';
+export { default as DocumentBody } from './consumers/document-body';
+export { default as WithDocumentActions } from './consumers/with-document-actions';
+export { default as ServiceProvider } from './provider/service-provider';
+export { default as Toolbar } from './components/toolbar';

package/dist/esm/model/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/provider/index.js

@@ -0,0 +1,18 @@
+import { default as ServiceProvider } from './service-provider';
+export { ServiceProvider };
+export var getProvider = function getProvider(_ref) {
+  var provider = _ref.provider,
+      url = _ref.url;
+
+  if (provider) {
+    return provider;
+  }
+
+  if (url) {
+    return new ServiceProvider({
+      url: url
+    });
+  }
+
+  throw new Error('Missing provider');
+};

package/dist/esm/provider/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/provider/service-provider.js

@@ -0,0 +1,229 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { utils } from '@atlaskit/util-service-support';
+
+function queryBuilder(data) {
+  return Object.keys(data).map(function (key) {
+    return [key, data[key]].map(encodeURIComponent).join('=');
+  }).join('&');
+}
+
+var ServiceProvider = /*#__PURE__*/function () {
+  function ServiceProvider(config) {
+    _classCallCheck(this, ServiceProvider);
+
+    this.config = config;
+  }
+
+  _createClass(ServiceProvider, [{
+    key: "getDocument",
+    value: function () {
+      var _getDocument = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(documentId, language) {
+        var document;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                _context.next = 3;
+                return utils.requestService(this.config, {
+                  path: "document/".concat(documentId, "/").concat(language || '')
+                });
+
+              case 3:
+                document = _context.sent;
+                return _context.abrupt("return", document);
+
+              case 7:
+                _context.prev = 7;
+                _context.t0 = _context["catch"](0);
+                // eslint-disable-next-line no-console
+                console.warn("Failed to get document: ".concat(JSON.stringify(_context.t0)));
+                return _context.abrupt("return", null);
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[0, 7]]);
+      }));
+
+      function getDocument(_x, _x2) {
+        return _getDocument.apply(this, arguments);
+      }
+
+      return getDocument;
+    }()
+  }, {
+    key: "getDocumentByObjectId",
+    value: function () {
+      var _getDocumentByObjectId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(objectId, language) {
+        var queryString, documents;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.prev = 0;
+                queryString = queryBuilder(_objectSpread({
+                  objectId: objectId
+                }, language ? {
+                  language: language
+                } : {}));
+                _context2.next = 4;
+                return utils.requestService(this.config, {
+                  path: "document?".concat(queryString)
+                });
+
+              case 4:
+                documents = _context2.sent;
+
+                if (!(documents && documents.length)) {
+                  _context2.next = 7;
+                  break;
+                }
+
+                return _context2.abrupt("return", documents[0].language[language || 'default'].versions[0]);
+
+              case 7:
+                return _context2.abrupt("return", null);
+
+              case 10:
+                _context2.prev = 10;
+                _context2.t0 = _context2["catch"](0);
+                // eslint-disable-next-line no-console
+                console.warn("Failed to get document: ".concat(JSON.stringify(_context2.t0)));
+                return _context2.abrupt("return", null);
+
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[0, 10]]);
+      }));
+
+      function getDocumentByObjectId(_x3, _x4) {
+        return _getDocumentByObjectId.apply(this, arguments);
+      }
+
+      return getDocumentByObjectId;
+    }()
+  }, {
+    key: "updateDocument",
+    value: function () {
+      var _updateDocument = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(documentId, body, objectId, title, language) {
+        var document;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.prev = 0;
+                _context3.next = 3;
+                return utils.requestService(this.config, {
+                  path: "document/".concat(documentId),
+                  requestInit: {
+                    headers: {
+                      'Content-Type': 'application/json'
+                    },
+                    method: 'PUT',
+                    body: JSON.stringify({
+                      body: body,
+                      objectId: objectId,
+                      title: title,
+                      language: language
+                    })
+                  }
+                });
+
+              case 3:
+                document = _context3.sent;
+                return _context3.abrupt("return", document);
+
+              case 7:
+                _context3.prev = 7;
+                _context3.t0 = _context3["catch"](0);
+                // eslint-disable-next-line no-console
+                console.warn("Failed to update document: ".concat(JSON.stringify(_context3.t0)));
+                return _context3.abrupt("return", null);
+
+              case 11:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[0, 7]]);
+      }));
+
+      function updateDocument(_x5, _x6, _x7, _x8, _x9) {
+        return _updateDocument.apply(this, arguments);
+      }
+
+      return updateDocument;
+    }()
+  }, {
+    key: "createDocument",
+    value: function () {
+      var _createDocument = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(body, objectId, title, language) {
+        var document;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.prev = 0;
+                _context4.next = 3;
+                return utils.requestService(this.config, {
+                  path: "document",
+                  requestInit: {
+                    headers: {
+                      'Content-Type': 'application/json'
+                    },
+                    method: 'POST',
+                    body: JSON.stringify({
+                      body: body,
+                      objectId: objectId,
+                      title: title,
+                      language: language
+                    })
+                  }
+                });
+
+              case 3:
+                document = _context4.sent;
+                return _context4.abrupt("return", document);
+
+              case 7:
+                _context4.prev = 7;
+                _context4.t0 = _context4["catch"](0);
+                // eslint-disable-next-line no-console
+                console.warn("Failed to update document: ".concat(JSON.stringify(_context4.t0)));
+                return _context4.abrupt("return", null);
+
+              case 11:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[0, 7]]);
+      }));
+
+      function createDocument(_x10, _x11, _x12, _x13) {
+        return _createDocument.apply(this, arguments);
+      }
+
+      return createDocument;
+    }()
+  }]);
+
+  return ServiceProvider;
+}();
+
+export { ServiceProvider as default };

package/dist/esm/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/embedded-document",
+	"version": "0.7.29",
+	"sideEffects": false
+}

package/dist/types/components/document.d.ts

@@ -0,0 +1,20 @@
+import { Component } from 'react';
+import { EditorProps } from '@atlaskit/editor-core';
+import { RendererProps } from '@atlaskit/renderer';
+import { Props as BaseProps } from '../context/embedded-document';
+import { Mode } from '../context/context';
+import { Document as DocumentModel } from '../model';
+export interface Props extends BaseProps {
+    doc?: DocumentModel;
+    isLoading?: boolean;
+    hasError?: boolean;
+    mode: Mode;
+    editorProps?: Partial<EditorProps>;
+    rendererProps?: Partial<RendererProps>;
+}
+export default class Document extends Component<Props> {
+    private renderToolbar;
+    private renderTitle;
+    private renderEditor;
+    render(): JSX.Element;
+}

package/dist/types/components/toolbar.d.ts

@@ -0,0 +1,6 @@
+import { Mode } from '../context/context';
+declare const _default: (props: {
+    mode: Mode;
+    editorActions?: any;
+}) => JSX.Element;
+export default _default;

package/dist/types/consumers/consumer.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { PureComponent } from 'react';
+import { Actions, State } from '../context/context';
+export interface Props<PropsFromState extends {}, PropsFromActions extends {}, RenderProps extends {}> {
+    stateMapper?: (state: State) => PropsFromState;
+    actionsMapper?: (actions: Actions) => PropsFromActions;
+    renderPropsMapper?: (renderProps: any) => RenderProps;
+    children: (props: PropsFromState & PropsFromActions & RenderProps) => React.ReactNode;
+}
+export interface ConsumerProps<A, V, R> {
+    actions: A;
+    value: V;
+    renderProps: R;
+}
+export declare class Consumer<PropsFromState extends {}, PropsFromActions extends {}, RenderProps extends {}> extends PureComponent<Props<PropsFromState, PropsFromActions, RenderProps>> {
+    private previousActions;
+    private propsFromActions;
+    private getPropsFromActions;
+    private getPropsFromState;
+    private getRenderProps;
+    private renderChildren;
+    render(): JSX.Element;
+}

package/dist/types/consumers/document-body.d.ts

@@ -0,0 +1,13 @@
+import { PureComponent } from 'react';
+import { EditorProps } from '@atlaskit/editor-core';
+import { RendererProps } from '@atlaskit/renderer';
+export interface Props {
+    editorProps?: Partial<EditorProps>;
+    rendererProps?: Partial<RendererProps>;
+}
+export default class DocumentBody extends PureComponent<Props> {
+    private renderChild;
+    private stateMapper;
+    private renderPropsMapper;
+    render(): JSX.Element;
+}

package/dist/types/consumers/with-document-actions.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { PureComponent } from 'react';
+import { Document as DocumentModel } from '../model';
+export interface Props {
+    render(actions: DocumentActions): React.ReactNode;
+}
+export interface DocumentActions {
+    createDocument(value: any): Promise<DocumentModel>;
+    editDocument(): void;
+    cancelEdit(): void;
+    updateDocument(value: any): Promise<DocumentModel>;
+}
+export default class WithDocumentActions extends PureComponent<Props> {
+    private actionsMapper;
+    render(): JSX.Element;
+}

package/dist/types/context/context.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { Document } from '../model';
+export interface ContextType {
+    value: State;
+    actions: Actions;
+    renderProps: any;
+}
+export interface State {
+    doc?: Document;
+    isLoading?: boolean;
+    hasError?: boolean;
+    mode?: Mode;
+}
+export declare type Mode = 'view' | 'edit' | 'create';
+export interface Actions {
+    getDocument(documentId: string, language?: string): void;
+    getDocumentByObjectId(objectId: string, language?: string): void;
+    setDocumentMode(mode: Mode): void;
+    updateDocument(body: string, title?: string, language?: string): Promise<Document>;
+    createDocument(body: string, title?: string, language?: string): Promise<Document>;
+}
+export declare const Context: import("react").Context<ContextType>;

package/dist/types/context/embedded-document.d.ts

@@ -0,0 +1,41 @@
+import { Component, ReactElement } from 'react';
+import { Mode, State } from './context';
+import { ProviderProps } from '../provider';
+export declare const akEditorFullPageMaxWidth = 680;
+export interface Props extends ProviderProps {
+    objectId: string;
+    documentId?: string;
+    containerId?: string;
+    language?: string;
+    mode?: Mode;
+    renderTitle?: (mode: Mode, doc?: any) => ReactElement<any>;
+    renderToolbar?: (mode: Mode, editorActions?: any) => ReactElement<any>;
+}
+export default class EmbeddedDocument extends Component<Props, State> {
+    private actions;
+    private provider;
+    constructor(props: Props);
+    componentDidMount(): Promise<void>;
+    private getDocumentByObjectId;
+    private getDocument;
+    private setDocumentMode;
+    private updateDocument;
+    private createDocument;
+    private setDocumentState;
+    /**
+     * Toolbar will only be rendered here if we're in "view"-mode.
+     *
+     * In all other modes, the toolbar rendering will be triggered
+     * by the Document-component.
+     */
+    private renderToolbar;
+    /**
+     * Title will only be rendered here if we're in "view"-mode.
+     *
+     * In all other modes, the title rendering will be triggered
+     * by the Document-component.
+     */
+    private renderTitle;
+    private renderContent;
+    render(): JSX.Element;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { default as EmbeddedDocument } from './context/embedded-document';
+export { default as DocumentBody } from './consumers/document-body';
+export { default as WithDocumentActions } from './consumers/with-document-actions';
+export { default as ServiceProvider } from './provider/service-provider';
+export { default as Toolbar } from './components/toolbar';
+export type { Mode as DocumentMode } from './context/context';
+export type { Document } from './model';
+export type { Provider } from './provider';

package/dist/types/model/index.d.ts

@@ -0,0 +1,19 @@
+export interface Document {
+    documentId: string;
+    objectId: string;
+    containerId?: string;
+    createdBy: User;
+    language?: string;
+    title?: string;
+    body: string;
+}
+export interface User {
+}
+export interface BatchDocumentResponse {
+    documentId: string;
+    language: {
+        [key: string]: {
+            versions: Document[];
+        };
+    };
+}