@jsonforms/core 3.0.0-alpha.3 → 3.0.0-beta.0

package/lib/util/resolvers.d.ts

@@ -1,25 +1,25 @@
-import { JsonSchema } from '../models';
-/**
- * Map for storing refs and the respective schemas they are pointing to.
- */
-export interface ReferenceSchemaMap {
-    [ref: string]: JsonSchema;
-}
-export declare const resolveData: (instance: any, dataPath: string) => any;
-/**
- * Finds all references inside the given schema.
- *
- * @param schema The {@link JsonSchema} to find the references in
- * @param result The initial result map, default: empty map (this parameter is used for recursion
- *               inside the function)
- * @param resolveTuples Whether arrays of tuples should be considered; default: false
- */
-export declare const findAllRefs: (schema: JsonSchema, result?: ReferenceSchemaMap, resolveTuples?: boolean) => ReferenceSchemaMap;
-/**
- * Resolve the given schema path in order to obtain a subschema.
- * @param {JsonSchema} schema the root schema from which to start
- * @param {string} schemaPath the schema path to be resolved
- * @param {JsonSchema} rootSchema the actual root schema
- * @returns {JsonSchema} the resolved sub-schema
- */
-export declare const resolveSchema: (schema: JsonSchema, schemaPath: string, rootSchema?: JsonSchema) => JsonSchema;
+import { JsonSchema } from '../models';
+/**
+ * Map for storing refs and the respective schemas they are pointing to.
+ */
+export interface ReferenceSchemaMap {
+    [ref: string]: JsonSchema;
+}
+export declare const resolveData: (instance: any, dataPath: string) => any;
+/**
+ * Finds all references inside the given schema.
+ *
+ * @param schema The {@link JsonSchema} to find the references in
+ * @param result The initial result map, default: empty map (this parameter is used for recursion
+ *               inside the function)
+ * @param resolveTuples Whether arrays of tuples should be considered; default: false
+ */
+export declare const findAllRefs: (schema: JsonSchema, result?: ReferenceSchemaMap, resolveTuples?: boolean) => ReferenceSchemaMap;
+/**
+ * Resolve the given schema path in order to obtain a subschema.
+ * @param {JsonSchema} schema the root schema from which to start
+ * @param {string} schemaPath the schema path to be resolved
+ * @param {JsonSchema} rootSchema the actual root schema
+ * @returns {JsonSchema} the resolved sub-schema
+ */
+export declare const resolveSchema: (schema: JsonSchema, schemaPath: string, rootSchema?: JsonSchema) => JsonSchema;

package/lib/util/runtime.d.ts

@@ -1,18 +1,18 @@
-import { UISchemaElement } from '../models';
-import Ajv from 'ajv';
-import { JsonFormsState } from '../store';
-import { JsonSchema } from '../models/jsonSchema';
-export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const hasShowRule: (uischema: UISchemaElement) => boolean;
-export declare const hasEnableRule: (uischema: UISchemaElement) => boolean;
-export declare const isVisible: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const isEnabled: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-/**
- * Indicates whether the given `uischema` element shall be enabled or disabled.
- * Checks the global readonly flag, uischema rule, uischema options (including the config),
- * the schema and the enablement indicator of the parent.
- */
-export declare const isInherentlyEnabled: (state: JsonFormsState, ownProps: any, uischema: UISchemaElement, schema: (JsonSchema & {
-    readOnly?: boolean;
-}) | undefined, rootData: any, config: any) => any;
+import { UISchemaElement } from '../models';
+import Ajv from 'ajv';
+import { JsonFormsState } from '../store';
+import { JsonSchema } from '../models/jsonSchema';
+export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const hasShowRule: (uischema: UISchemaElement) => boolean;
+export declare const hasEnableRule: (uischema: UISchemaElement) => boolean;
+export declare const isVisible: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const isEnabled: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+/**
+ * Indicates whether the given `uischema` element shall be enabled or disabled.
+ * Checks the global readonly flag, uischema rule, uischema options (including the config),
+ * the schema and the enablement indicator of the parent.
+ */
+export declare const isInherentlyEnabled: (state: JsonFormsState, ownProps: any, uischema: UISchemaElement, schema: (JsonSchema & {
+    readOnly?: boolean;
+}) | undefined, rootData: any, config: any) => any;

package/lib/util/schema.d.ts

@@ -1 +1 @@
-export declare const getFirstPrimitiveProp: (schema: any) => string;
+export declare const getFirstPrimitiveProp: (schema: any) => string;

package/lib/util/type.d.ts

@@ -1,174 +1,174 @@
-export interface Action<T = any> {
-    type: T;
-}
-/**
- * An Action type which accepts any other properties.
- * This is mainly for the use of the `Reducer` type.
- * This is not part of `Action` itself to prevent types that extend `Action` from
- * having an index signature.
- */
-export interface AnyAction extends Action {
-    [extraProps: string]: any;
-}
-/**
- * A *dispatching function* (or simply *dispatch function*) is a function that
- * accepts an action or an async action; it then may or may not dispatch one
- * or more actions to the store.
- *
- * We must distinguish between dispatching functions in general and the base
- * `dispatch` function provided by the store instance without any middleware.
- *
- * The base dispatch function *always* synchronously sends an action to the
- * store's reducer, along with the previous state returned by the store, to
- * calculate a new state. It expects actions to be plain objects ready to be
- * consumed by the reducer.
- *
- * Middleware wraps the base dispatch function. It allows the dispatch
- * function to handle async actions in addition to actions. Middleware may
- * transform, delay, ignore, or otherwise interpret actions or async actions
- * before passing them to the next middleware.
- *
- * @template A The type of things (actions or otherwise) which may be
- *   dispatched.
- */
-export declare type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
-/**
- * A store is an object that holds the application's state tree.
- * There should only be a single store in a Redux app, as the composition
- * happens on the reducer level.
- *
- * @template S The type of state held by this store.
- * @template A the type of actions which may be dispatched by this store.
- */
-export interface Store<S = any, A extends Action = AnyAction> {
-    /**
-     * Dispatches an action. It is the only way to trigger a state change.
-     *
-     * The `reducer` function, used to create the store, will be called with the
-     * current state tree and the given `action`. Its return value will be
-     * considered the **next** state of the tree, and the change listeners will
-     * be notified.
-     *
-     * The base implementation only supports plain object actions. If you want
-     * to dispatch a Promise, an Observable, a thunk, or something else, you
-     * need to wrap your store creating function into the corresponding
-     * middleware. For example, see the documentation for the `redux-thunk`
-     * package. Even the middleware will eventually dispatch plain object
-     * actions using this method.
-     *
-     * @param action A plain object representing “what changed”. It is a good
-     *   idea to keep actions serializable so you can record and replay user
-     *   sessions, or use the time travelling `redux-devtools`. An action must
-     *   have a `type` property which may not be `undefined`. It is a good idea
-     *   to use string constants for action types.
-     *
-     * @returns For convenience, the same action object you dispatched.
-     *
-     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
-     * return something else (for example, a Promise you can await).
-     */
-    dispatch: Dispatch<A>;
-    /**
-     * Reads the state tree managed by the store.
-     *
-     * @returns The current state tree of your application.
-     */
-    getState(): S;
-    /**
-     * Adds a change listener. It will be called any time an action is
-     * dispatched, and some part of the state tree may potentially have changed.
-     * You may then call `getState()` to read the current state tree inside the
-     * callback.
-     *
-     * You may call `dispatch()` from a change listener, with the following
-     * caveats:
-     *
-     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
-     * If you subscribe or unsubscribe while the listeners are being invoked,
-     * this will not have any effect on the `dispatch()` that is currently in
-     * progress. However, the next `dispatch()` call, whether nested or not,
-     * will use a more recent snapshot of the subscription list.
-     *
-     * 2. The listener should not expect to see all states changes, as the state
-     * might have been updated multiple times during a nested `dispatch()` before
-     * the listener is called. It is, however, guaranteed that all subscribers
-     * registered before the `dispatch()` started will be called with the latest
-     * state by the time it exits.
-     *
-     * @param listener A callback to be invoked on every dispatch.
-     * @returns A function to remove this change listener.
-     */
-    subscribe(listener: () => void): Unsubscribe;
-    /**
-     * Replaces the reducer currently used by the store to calculate the state.
-     *
-     * You might need this if your app implements code splitting and you want to
-     * load some of the reducers dynamically. You might also need this if you
-     * implement a hot reloading mechanism for Redux.
-     *
-     * @param nextReducer The reducer for the store to use instead.
-     */
-    replaceReducer(nextReducer: Reducer<S, A>): void;
-    /**
-     * Interoperability point for observable/reactive libraries.
-     * @returns {observable} A minimal observable of state changes.
-     * For more information, see the observable proposal:
-     * https://github.com/tc39/proposal-observable
-     */
-    [Symbol.observable](): Observable<S>;
-}
-/**
- * A minimal observable of state changes.
- * For more information, see the observable proposal:
- * https://github.com/tc39/proposal-observable
- */
-export declare type Observable<T> = {
-    /**
-     * The minimal observable subscription method.
-     * @param {Object} observer Any object that can be used as an observer.
-     * The observer object should have a `next` method.
-     * @returns {subscription} An object with an `unsubscribe` method that can
-     * be used to unsubscribe the observable from the store, and prevent further
-     * emission of values from the observable.
-     */
-    subscribe(observer: Observer<T>): {
-        unsubscribe: Unsubscribe;
-    };
-    [Symbol.observable](): Observable<T>;
-};
-/**
- * An Observer is used to receive data from an Observable, and is supplied as
- * an argument to subscribe.
- */
-export declare type Observer<T> = {
-    next?(value: T): void;
-};
-/**
- * A *reducer* (also called a *reducing function*) is a function that accepts
- * an accumulation and a value and returns a new accumulation. They are used
- * to reduce a collection of values down to a single value
- *
- * Reducers are not unique to Redux—they are a fundamental concept in
- * functional programming.  Even most non-functional languages, like
- * JavaScript, have a built-in API for reducing. In JavaScript, it's
- * `Array.prototype.reduce()`.
- *
- * In Redux, the accumulated value is the state object, and the values being
- * accumulated are actions. Reducers calculate a new state given the previous
- * state and an action. They must be *pure functions*—functions that return
- * the exact same output for given inputs. They should also be free of
- * side-effects. This is what enables exciting features like hot reloading and
- * time travel.
- *
- * Reducers are the most important concept in Redux.
- *
- * *Do not put API calls into reducers.*
- *
- * @template S The type of state consumed and produced by this reducer.
- * @template A The type of actions the reducer can potentially respond to.
- */
-export declare type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
-/**
- * Function to remove listener added by `Store.subscribe()`.
- */
-export declare type Unsubscribe = () => void;
+export interface Action<T = any> {
+    type: T;
+}
+/**
+ * An Action type which accepts any other properties.
+ * This is mainly for the use of the `Reducer` type.
+ * This is not part of `Action` itself to prevent types that extend `Action` from
+ * having an index signature.
+ */
+export interface AnyAction extends Action {
+    [extraProps: string]: any;
+}
+/**
+ * A *dispatching function* (or simply *dispatch function*) is a function that
+ * accepts an action or an async action; it then may or may not dispatch one
+ * or more actions to the store.
+ *
+ * We must distinguish between dispatching functions in general and the base
+ * `dispatch` function provided by the store instance without any middleware.
+ *
+ * The base dispatch function *always* synchronously sends an action to the
+ * store's reducer, along with the previous state returned by the store, to
+ * calculate a new state. It expects actions to be plain objects ready to be
+ * consumed by the reducer.
+ *
+ * Middleware wraps the base dispatch function. It allows the dispatch
+ * function to handle async actions in addition to actions. Middleware may
+ * transform, delay, ignore, or otherwise interpret actions or async actions
+ * before passing them to the next middleware.
+ *
+ * @template A The type of things (actions or otherwise) which may be
+ *   dispatched.
+ */
+export declare type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
+/**
+ * A store is an object that holds the application's state tree.
+ * There should only be a single store in a Redux app, as the composition
+ * happens on the reducer level.
+ *
+ * @template S The type of state held by this store.
+ * @template A the type of actions which may be dispatched by this store.
+ */
+export interface Store<S = any, A extends Action = AnyAction> {
+    /**
+     * Dispatches an action. It is the only way to trigger a state change.
+     *
+     * The `reducer` function, used to create the store, will be called with the
+     * current state tree and the given `action`. Its return value will be
+     * considered the **next** state of the tree, and the change listeners will
+     * be notified.
+     *
+     * The base implementation only supports plain object actions. If you want
+     * to dispatch a Promise, an Observable, a thunk, or something else, you
+     * need to wrap your store creating function into the corresponding
+     * middleware. For example, see the documentation for the `redux-thunk`
+     * package. Even the middleware will eventually dispatch plain object
+     * actions using this method.
+     *
+     * @param action A plain object representing “what changed”. It is a good
+     *   idea to keep actions serializable so you can record and replay user
+     *   sessions, or use the time travelling `redux-devtools`. An action must
+     *   have a `type` property which may not be `undefined`. It is a good idea
+     *   to use string constants for action types.
+     *
+     * @returns For convenience, the same action object you dispatched.
+     *
+     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+     * return something else (for example, a Promise you can await).
+     */
+    dispatch: Dispatch<A>;
+    /**
+     * Reads the state tree managed by the store.
+     *
+     * @returns The current state tree of your application.
+     */
+    getState(): S;
+    /**
+     * Adds a change listener. It will be called any time an action is
+     * dispatched, and some part of the state tree may potentially have changed.
+     * You may then call `getState()` to read the current state tree inside the
+     * callback.
+     *
+     * You may call `dispatch()` from a change listener, with the following
+     * caveats:
+     *
+     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+     * If you subscribe or unsubscribe while the listeners are being invoked,
+     * this will not have any effect on the `dispatch()` that is currently in
+     * progress. However, the next `dispatch()` call, whether nested or not,
+     * will use a more recent snapshot of the subscription list.
+     *
+     * 2. The listener should not expect to see all states changes, as the state
+     * might have been updated multiple times during a nested `dispatch()` before
+     * the listener is called. It is, however, guaranteed that all subscribers
+     * registered before the `dispatch()` started will be called with the latest
+     * state by the time it exits.
+     *
+     * @param listener A callback to be invoked on every dispatch.
+     * @returns A function to remove this change listener.
+     */
+    subscribe(listener: () => void): Unsubscribe;
+    /**
+     * Replaces the reducer currently used by the store to calculate the state.
+     *
+     * You might need this if your app implements code splitting and you want to
+     * load some of the reducers dynamically. You might also need this if you
+     * implement a hot reloading mechanism for Redux.
+     *
+     * @param nextReducer The reducer for the store to use instead.
+     */
+    replaceReducer(nextReducer: Reducer<S, A>): void;
+    /**
+     * Interoperability point for observable/reactive libraries.
+     * @returns {observable} A minimal observable of state changes.
+     * For more information, see the observable proposal:
+     * https://github.com/tc39/proposal-observable
+     */
+    [Symbol.observable](): Observable<S>;
+}
+/**
+ * A minimal observable of state changes.
+ * For more information, see the observable proposal:
+ * https://github.com/tc39/proposal-observable
+ */
+export declare type Observable<T> = {
+    /**
+     * The minimal observable subscription method.
+     * @param {Object} observer Any object that can be used as an observer.
+     * The observer object should have a `next` method.
+     * @returns {subscription} An object with an `unsubscribe` method that can
+     * be used to unsubscribe the observable from the store, and prevent further
+     * emission of values from the observable.
+     */
+    subscribe(observer: Observer<T>): {
+        unsubscribe: Unsubscribe;
+    };
+    [Symbol.observable](): Observable<T>;
+};
+/**
+ * An Observer is used to receive data from an Observable, and is supplied as
+ * an argument to subscribe.
+ */
+export declare type Observer<T> = {
+    next?(value: T): void;
+};
+/**
+ * A *reducer* (also called a *reducing function*) is a function that accepts
+ * an accumulation and a value and returns a new accumulation. They are used
+ * to reduce a collection of values down to a single value
+ *
+ * Reducers are not unique to Redux—they are a fundamental concept in
+ * functional programming.  Even most non-functional languages, like
+ * JavaScript, have a built-in API for reducing. In JavaScript, it's
+ * `Array.prototype.reduce()`.
+ *
+ * In Redux, the accumulated value is the state object, and the values being
+ * accumulated are actions. Reducers calculate a new state given the previous
+ * state and an action. They must be *pure functions*—functions that return
+ * the exact same output for given inputs. They should also be free of
+ * side-effects. This is what enables exciting features like hot reloading and
+ * time travel.
+ *
+ * Reducers are the most important concept in Redux.
+ *
+ * *Do not put API calls into reducers.*
+ *
+ * @template S The type of state consumed and produced by this reducer.
+ * @template A The type of actions the reducer can potentially respond to.
+ */
+export declare type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
+/**
+ * Function to remove listener added by `Store.subscribe()`.
+ */
+export declare type Unsubscribe = () => void;

package/lib/util/uischema.d.ts

@@ -1,5 +1,5 @@
-import { UISchemaElement } from '../models';
-export declare type IterateCallback = (uischema: UISchemaElement) => void;
-export declare const setReadonly: (uischema: UISchemaElement) => void;
-export declare const unsetReadonly: (uischema: UISchemaElement) => void;
-export declare const iterateSchema: (uischema: UISchemaElement, toApply: IterateCallback) => void;
+import { UISchemaElement } from '../models';
+export declare type IterateCallback = (uischema: UISchemaElement) => void;
+export declare const setReadonly: (uischema: UISchemaElement) => void;
+export declare const unsetReadonly: (uischema: UISchemaElement) => void;
+export declare const iterateSchema: (uischema: UISchemaElement, toApply: IterateCallback) => void;

package/lib/util/util.d.ts

@@ -1,31 +1,31 @@
-import { JsonSchema, Scopable, UISchemaElement } from '..';
-import Ajv from 'ajv';
-/**
- * Escape the given string such that it can be used as a class name,
- * i.e. hashes and slashes will be replaced.
- *
- * @param {string} s the string that should be converted to a valid class name
- * @returns {string} the escaped string
- */
-export declare const convertToValidClassName: (s: string) => string;
-export declare const formatErrorMessage: (errors: string[]) => string;
-export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
-/**
-* Derives the type of the jsonSchema element
-*/
-export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
-/**
-* Convenience wrapper around resolveData and resolveSchema.
-*/
-export declare const Resolve: {
-    schema(schema: JsonSchema, schemaPath: string, rootSchema?: JsonSchema): JsonSchema;
-    data(data: any, path: string): any;
-};
-export declare const Paths: {
-    compose: (path1: string, path2: string) => string;
-    fromScopable: (scopable: Scopable) => string;
-};
-export declare const Runtime: {
-    isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
-    isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
-};
+import { JsonSchema, Scopable, UISchemaElement } from '..';
+import Ajv from 'ajv';
+/**
+ * Escape the given string such that it can be used as a class name,
+ * i.e. hashes and slashes will be replaced.
+ *
+ * @param {string} s the string that should be converted to a valid class name
+ * @returns {string} the escaped string
+ */
+export declare const convertToValidClassName: (s: string) => string;
+export declare const formatErrorMessage: (errors: string[]) => string;
+export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
+/**
+* Derives the type of the jsonSchema element
+*/
+export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
+/**
+* Convenience wrapper around resolveData and resolveSchema.
+*/
+export declare const Resolve: {
+    schema(schema: JsonSchema, schemaPath: string, rootSchema?: JsonSchema): JsonSchema;
+    data(data: any, path: string): any;
+};
+export declare const Paths: {
+    compose: (path1: string, path2: string) => string;
+    fromScopable: (scopable: Scopable) => string;
+};
+export declare const Runtime: {
+    isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
+    isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
+};

package/lib/util/validator.d.ts

@@ -1,3 +1,3 @@
-import Ajv from 'ajv';
-import { Options } from 'ajv';
-export declare const createAjv: (options?: Options) => Ajv;
+import Ajv from 'ajv';
+import { Options } from 'ajv';
+export declare const createAjv: (options?: Options) => Ajv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonforms/core",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-beta.0",
   "description": "Core module of JSON Forms",
   "repository": "https://github.com/eclipsesource/jsonforms",
   "bugs": "https://github.com/eclipsesource/jsonforms/issues",
@@ -29,16 +29,16 @@
     "layout",
     "customization"
   ],
-  "main": "./lib/index.js",
+  "main": "lib/jsonforms-core.cjs.js",
+  "module": "lib/jsonforms-core.esm.js",
   "typings": "./lib/index.d.ts",
   "scripts": {
-    "bundle": "webpack --config ./webpack.build.js --env=production --display-error-details",
-    "build": "tsc",
+    "build": "rollup -c rollup.config.js",
     "clean": "rimraf -rf lib coverage dist .nyc_output 2> /dev/null",
     "lint": "tslint --project tsconfig.json --exclude src/models/jsonSchema.ts",
     "report": "nyc report --reporter=html",
-    "test": "ava",
-    "test-cov": "rimraf -rf .nyc_output && nyc ava",
+    "test": "cross-env TS_NODE_COMPILER_OPTIONS={\\\"module\\\":\\\"commonjs\\\",\\\"target\\\":\\\"es5\\\"} ava",
+    "test-cov": "rimraf -rf .nyc_output && cross-env TS_NODE_COMPILER_OPTIONS={\\\"module\\\":\\\"commonjs\\\",\\\"target\\\":\\\"es5\\\"} nyc ava",
     "doc": "typedoc --name 'JSON Forms Core' --mode file --excludeExternals --theme ../../typedoc-jsonforms --out docs src"
   },
   "ava": {
@@ -67,23 +67,26 @@
     "lodash": "^4.17.15"
   },
   "devDependencies": {
-    "@istanbuljs/nyc-config-typescript": "0.1.3",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/redux-mock-store": "^1.0.1",
     "ava": "~2.4.0",
+    "cross-env": "^7.0.2",
     "document-register-element": "^1.14.3",
     "jsdom": "^15.2.1",
     "jsdom-global": "^3.0.2",
-    "nyc": "^14.1.1",
+    "nyc": "^15.1.0",
     "redux": "^4.0.4",
     "redux-mock-store": "1.5.3",
     "rimraf": "^3.0.2",
+    "rollup": "^2.7.3",
+    "rollup-plugin-cleanup": "^3.2.1",
+    "rollup-plugin-typescript2": "^0.31.1",
+    "rollup-plugin-visualizer": "^5.4.1",
     "source-map-support": "0.5.16",
-    "ts-node": "^8.5.3",
+    "ts-node": "^10.4.0",
     "tslint": "^5.20.1",
     "typedoc": "^0.19.2",
-    "typescript": "4.2.3",
-    "webpack": "^4.41.2",
-    "webpack-cli": "^3.2.1"
+    "typescript": "4.2.3"
   },
-  "gitHead": "81f1f19dac49b1864e712e9abbc5c5c6355a2b91"
+  "gitHead": "8540d2f63abe25ee079192bc7d45e7ba4be00eac"
 }

package/rollup.config.js

@@ -0,0 +1,44 @@
+import typescript from 'rollup-plugin-typescript2';
+import cleanup from 'rollup-plugin-cleanup';
+import { visualizer } from 'rollup-plugin-visualizer';
+
+const packageJson = require('./package.json');
+
+const baseConfig = {
+  input: 'src/index.ts',
+  external: [...Object.keys(packageJson.dependencies), /^lodash\/.*/]
+};
+
+export default [
+  {
+    ...baseConfig,
+    output: {
+      file: packageJson.module,
+      format: 'esm',
+      sourcemap: true
+    },
+    plugins: [
+      typescript(),
+      cleanup({ extensions: ['js', 'ts', 'jsx', 'tsx'] }),
+      visualizer({ open: false })
+    ]
+  },
+  {
+    ...baseConfig,
+    output: {
+      file: packageJson.main,
+      format: 'cjs',
+      sourcemap: true
+    },
+    plugins: [
+      typescript({
+        tsconfigOverride: {
+          compilerOptions: {
+            target: 'ES5'
+          }
+        }
+      }),
+      cleanup({ extensions: ['js', 'ts', 'jsx', 'tsx'] })
+    ]
+  }
+];