anu-verzum 1.0.0

package/babel-preset.js

@@ -0,0 +1,13 @@
+module.exports = function () {
+    return {
+        plugins: [
+            [
+                require('@babel/plugin-transform-react-jsx'),
+                {
+                    pragma: 'Anu.createElement',
+                    pragmaFrag: 'Anu.Fragment'
+                }
+            ]
+        ]
+    };
+};

package/dist/core/components/AnulyticsProvider.js

@@ -0,0 +1,227 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackStateChange = exports.trackRouteChange = exports.trackEvent = exports.default = void 0;
+var _Component = require("./Component");
+var _serverApi = _interopRequireDefault(require("../../server-api/server-api"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const EventTypes = {
+  INITIALIZATION: 'initialization',
+  USER_ACTION: 'userAction',
+  STATE_CHANGE: 'stateChange',
+  NAVIGATION: 'navigation',
+  PAGE_LEAVE: 'pageLeave'
+};
+const AnulyticsState = (() => {
+  const initStart = new Date().getTime();
+  let _anulyticsInstanceExist = false;
+  const setAnulyticsInstanceExist = instanceExist => {
+    _anulyticsInstanceExist = instanceExist;
+  };
+  const getAnulyticsInstanceExist = () => _anulyticsInstanceExist;
+  let _anulytics = {
+    startDate: initStart,
+    events: [{
+      [EventTypes.INITIALIZATION]: {
+        eventType: window.location.pathname,
+        timestamp: initStart,
+        properties: {}
+      }
+    }],
+    user: {}
+  };
+  return {
+    getAnulyticsInstanceExist,
+    setAnulyticsInstanceExist,
+    addEvent: (key, val) => {
+      _anulytics.events.push({
+        [key]: val
+      });
+    },
+    trackEvent: ({
+      type,
+      keyCode = null,
+      pageX = 0,
+      pageY = 0,
+      target: {
+        id,
+        name,
+        nodeName,
+        value
+      } = {
+        id: '',
+        name: '',
+        nodeName: '',
+        value: ''
+      }
+    }, rawProps) => {
+      const scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
+      const scrollLeft = document.body.scrollLeft || document.documentElement.scrollLeft;
+      const props = typeof rawProps === 'object' && !Array.isArray(rawProps) ? rawProps : null;
+      const event = {
+        [EventTypes.USER_ACTION]: {
+          eventType: type,
+          timestamp: new Date().getTime(),
+          properties: {
+            id,
+            keyCode,
+            name,
+            nodeName,
+            value,
+            pageX,
+            pageY,
+            scrollTop,
+            scrollLeft,
+            url: window.location.pathname,
+            props
+          }
+        }
+      };
+      _anulytics.events.push(event);
+    },
+    trackStateChange: (prevState, action, nextState) => {
+      const event = {
+        [EventTypes.STATE_CHANGE]: {
+          eventType: action.type,
+          timestamp: new Date().getTime(),
+          properties: {
+            url: window.location.pathname,
+            prevState,
+            action,
+            nextState
+          }
+        }
+      };
+      _anulytics.events.push(event);
+    },
+    setUser: user => {
+      _anulytics.user = user || {};
+    },
+    getAnulyticsData: () => _anulytics
+  };
+})();
+const _isBot = window.phantom || window._phantom || window.__nightmare || window.navigator.webdriver || window.Cypress;
+const _isInstalled = () => {
+  if (window.navigator.standalone) {
+    return true;
+  }
+  if (window.matchMedia('(display-mode: standalone)').matches) {
+    return true;
+  }
+  return false;
+};
+const trackEvent = (event, props) => {
+  if (AnulyticsState.getAnulyticsInstanceExist()) {
+    AnulyticsState.trackEvent(event, props);
+  }
+};
+exports.trackEvent = trackEvent;
+const trackStateChange = (prevState, action, nextState) => {
+  if (AnulyticsState.getAnulyticsInstanceExist()) {
+    AnulyticsState.trackStateChange(prevState, action, nextState);
+  }
+};
+exports.trackStateChange = trackStateChange;
+const trackRouteChange = path => {
+  if (AnulyticsState.getAnulyticsInstanceExist()) {
+    const url = path || window.location.pathname;
+    const event = {
+      eventType: url,
+      timestamp: new Date().getTime(),
+      properties: {}
+    };
+    AnulyticsState.addEvent(EventTypes.NAVIGATION, event);
+  }
+};
+exports.trackRouteChange = trackRouteChange;
+class AnulyticsProvider extends _Component.Component {
+  constructor(props) {
+    super(props);
+    AnulyticsState.setAnulyticsInstanceExist(true);
+    this.handleVisibilityChange = this.handleVisibilityChange.bind(this);
+  }
+  componentDidMount() {
+    const {
+      userData
+    } = this.props;
+    AnulyticsState.setUser(userData);
+    document.addEventListener('visibilitychange', this.handleVisibilityChange, {
+      passive: true
+    });
+  }
+  componentWillUnmount() {
+    document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+    AnulyticsState.setAnulyticsInstanceExist(false);
+  }
+  handleVisibilityChange() {
+    const {
+      analyticsUrl,
+      onSuccess,
+      onFail
+    } = this.props;
+    if (_isBot) {
+      return;
+    }
+    if (document.visibilityState === 'hidden') {
+      const url = window.location.pathname;
+      const event = {
+        eventType: url,
+        timestamp: new Date().getTime(),
+        properties: {}
+      };
+      let ua;
+      AnulyticsState.addEvent(EventTypes.PAGE_LEAVE, event);
+      if (window.navigator.userAgentData) {
+        const {
+          brands,
+          mobile,
+          platform
+        } = window.navigator.userAgentData;
+        ua = {
+          userAgent: brands,
+          mobile,
+          platform
+        };
+      } else {
+        ua = {
+          userAgent: window.navigator.userAgent,
+          mobile: false,
+          platform: ''
+        };
+      }
+      const data = {
+        ...AnulyticsState.getAnulyticsData(),
+        endDate: new Date().getTime(),
+        system: {
+          referrer: document.referrer || null,
+          innerWidth: window.innerWidth,
+          isMobileAppInstalled: _isInstalled(),
+          userAgentData: ua
+        }
+      };
+      _serverApi.default.post(analyticsUrl, data).then(({
+        response
+      }) => onSuccess(response)).catch(({
+        status
+      }) => onFail(status));
+    } else {
+      this.setState();
+    }
+  }
+  render() {
+    const {
+      children
+    } = this.props;
+    try {
+      if (children.length !== 1) {
+        throw new Error('Provider must have one child element!');
+      }
+      return children;
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+var _default = exports.default = AnulyticsProvider;

package/dist/core/components/Component.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Component = void 0;
+var _reconciler = require("../reconciler");
+class Component {
+  constructor(props, context) {
+    this.props = props || {};
+    this.context = {
+      ...this.context,
+      ...context
+    } || {};
+    this.state = this.state || {};
+  }
+  setState(partialState = {}) {
+    let partialStateObject = this.state;
+    let partialStateCallback;
+    if (typeof partialState === 'object') {
+      partialStateObject = {
+        ...partialStateObject,
+        ...partialState
+      };
+    } else if (typeof partialState === 'function') {
+      partialStateCallback = partialState;
+    }
+    (0, _reconciler.scheduleUpdate)(this, partialStateObject, partialStateCallback);
+  }
+  componentDidMount() {}
+  componentDidUpdate(prevProps, prevState) {}
+  componentWillUnmount() {}
+}
+exports.Component = Component;

package/dist/core/components/Connector.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elements = require("../elements");
+var _Component = require("./Component");
+const providedStore = (context = {}) => {
+  let providerContext = {
+    ...context
+  };
+  return {
+    getContext: () => providerContext,
+    setContext: context => {
+      providerContext = {
+        ...providerContext,
+        ...context
+      };
+    }
+  };
+};
+const providerStore = providedStore();
+class Provider extends _Component.Component {
+  constructor(props, context) {
+    super(props, context);
+    this.store = props.store;
+    this.context.store = props.store;
+    this.context.parentSub = null;
+    providerStore.setContext({
+      ...this.context
+    });
+  }
+  render() {
+    const {
+      children
+    } = this.props;
+    try {
+      if (children.length !== 1) {
+        throw new Error('Provider must have one child element!');
+      }
+      return children;
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+class Subscription {
+  constructor(store, parentSub, onStateChange) {
+    this.store = store;
+    this.parentSub = parentSub;
+    this.onStateChange = onStateChange;
+    this.subscribed = false;
+    this.listeners = [];
+  }
+  notifyNestedSubs() {
+    this.listeners.forEach(listener => listener());
+  }
+  trySubscribe() {
+    if (!this.subscribed) {
+      if (this.parentSub !== null) {
+        this.parentSub.addNestedSub(this.onStateChange);
+      } else {
+        this.store.subscribe(this.onStateChange);
+      }
+      this.subscribed = true;
+    }
+  }
+  addNestedSub(listener) {
+    this.trySubscribe();
+    this.listeners.push(listener);
+  }
+  tryUnsubscribe() {
+    if (this.subscribed) {
+      if (this.parentSub !== null) {
+        this.parentSub.removeNestedSub(this.onStateChange);
+      } else {
+        this.store.unsubscribe(this.onStateChange);
+      }
+      this.subscribed = false;
+    }
+  }
+  removeNestedSub(listener) {
+    this.tryUnsubscribe();
+    const index = this.listeners.indexOf(listener);
+    if (index >= 0) {
+      this.listeners.splice(index, 1);
+    }
+  }
+}
+const connectHOC = (mapStateToProps, mapDispatchToProps) => WrappedComponent => {
+  class Connect extends _Component.Component {
+    constructor(props, context) {
+      super(props, context);
+      this.context = {
+        ...this.context,
+        ...providerStore.getContext()
+      };
+      this.store = this.context.store;
+      const parentSub = this.context.parentSub;
+      this.subscription = new Subscription(this.store, parentSub, this.onStateChange.bind(this));
+      this.context.parentSub = this.subscription;
+    }
+    componentDidMount() {
+      this.subscription.trySubscribe();
+    }
+    componentWillUnmount() {
+      this.subscription.tryUnsubscribe();
+    }
+    componentDidUpdate() {
+      this.subscription.notifyNestedSubs();
+    }
+    onStateChange() {
+      this.setState({});
+    }
+    render() {
+      const stateProps = mapStateToProps ? mapStateToProps(this.store.getState(), this.props) : {};
+      const dispatchProps = mapDispatchToProps ? mapDispatchToProps(this.store.dispatch, this.props) : {};
+      const passedProps = {
+        ...this.props,
+        ...stateProps,
+        ...dispatchProps
+      };
+      return (0, _elements.createElement)(WrappedComponent, passedProps);
+    }
+  }
+  return Connect;
+};
+const Connector = {
+  connect: connectHOC,
+  Provider
+};
+var _default = exports.default = Connector;

package/dist/core/components/Context.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContext = void 0;
+var _utils = require("../../misc/utils");
+var _Component = require("./Component");
+const createContext = context => {
+  const providerContext = {
+    defaultContext: {
+      value: context
+    },
+    value: {}
+  };
+  const getPureProps = props => {
+    const pureProps = {};
+    Object.keys(props).forEach(key => {
+      if (key !== 'children') {
+        pureProps[key] = props[key];
+      }
+    });
+    return pureProps;
+  };
+  class ContextProvider extends _Component.Component {
+    constructor(props) {
+      super(props);
+      providerContext.value = {
+        ...getPureProps(props)
+      };
+    }
+    componentDidUpdate() {
+      const pureProps = getPureProps(this.props);
+      if (!(0, _utils.deepEqual)(providerContext.value, pureProps)) {
+        providerContext.value = {
+          ...pureProps
+        };
+        this.setState();
+      }
+    }
+    render() {
+      const {
+        children
+      } = this.props;
+      try {
+        if (children.length !== 1) {
+          throw new Error('Context Component must have exactly one child element!');
+        }
+        return children;
+      } catch (err) {
+        console.error(err);
+      }
+    }
+  }
+  class ContextConsumer extends _Component.Component {
+    constructor(props) {
+      super(props);
+    }
+    componentDidUpdate() {
+      if (providerContext.__notifySub) {
+        this.setState();
+      }
+    }
+    render() {
+      const {
+        children
+      } = this.props;
+      const {
+        value,
+        defaultContext
+      } = providerContext;
+      try {
+        if (children.length !== 1) {
+          throw new Error('Context Component must have exactly one child element!');
+        }
+        const {
+          type
+        } = children[0];
+        const childProps = {
+          value,
+          defaultContext
+        };
+        if (typeof type === 'function') {
+          return type(childProps);
+        } else {
+          throw new Error('Context component child element must be a function!');
+        }
+      } catch (err) {
+        console.error(err);
+      }
+    }
+  }
+  return {
+    Provider: ContextProvider,
+    Consumer: ContextConsumer
+  };
+};
+exports.createContext = createContext;

package/dist/core/components/Feature.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elements = require("../elements");
+var _Context = require("./Context");
+const defaultFeatures = {};
+const FeaturesContext = (0, _Context.createContext)(defaultFeatures);
+const FeatureToggle = ({
+  name,
+  children,
+  defaultComponent = null
+}) => (0, _elements.createElement)(FeaturesContext.ContextConsumer, {}, ({
+  value: {
+    features
+  }
+}) => features[name] === true ? children : defaultComponent);
+const Feature = {
+  Provider: FeaturesContext.ContextProvider,
+  Toggle: FeatureToggle
+};
+var _default = exports.default = Feature;

package/dist/core/components/Fragment.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fragment = void 0;
+var _Component = require("./Component");
+class Fragment extends _Component.Component {
+  render() {
+    const {
+      children
+    } = this.props;
+    try {
+      if (!children.length) {
+        throw new Error('Fragment must have at least one child element!');
+      }
+      return children;
+    } catch (err) {
+      console.error(err);
+      return [];
+    }
+  }
+}
+exports.Fragment = Fragment;

package/dist/core/components/History.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.goTo = exports.default = void 0;
+var _elements = require("../elements");
+var _Component = require("./Component");
+var _AnulyticsProvider = require("./AnulyticsProvider");
+const instances = [];
+const register = comp => {
+  instances.push(comp);
+};
+const unregister = comp => {
+  const index = instances.indexOf(comp);
+  if (index >= 0) {
+    instances.splice(index, 1);
+  }
+};
+const hasHistoryAPI = typeof window !== 'undefined' && typeof window.history !== 'undefined' && typeof window.history.pushState === 'function';
+const historyPush = path => {
+  (0, _AnulyticsProvider.trackRouteChange)(path);
+  if (hasHistoryAPI) {
+    history.pushState({}, null, path);
+  } else {
+    console.warn('History API not available - running in non-browser environment');
+  }
+  instances.forEach(instance => {
+    instance.setState();
+  });
+};
+const historyReplace = path => {
+  (0, _AnulyticsProvider.trackRouteChange)(path);
+  if (hasHistoryAPI) {
+    history.replaceState({}, null, path);
+  } else {
+    console.warn('History API not available - running in non-browser environment');
+  }
+  instances.forEach(instance => {
+    instance.setState();
+  });
+};
+const matchPath = (pathname, options) => {
+  const {
+    exact = false,
+    path
+  } = options;
+  if (!path) {
+    return {
+      path: null,
+      url: pathname,
+      isExact: true
+    };
+  }
+  const match = new RegExp(`^${path}`).exec(pathname);
+  if (!match) {
+    return null;
+  }
+  const url = match[0];
+  const isExact = pathname === url;
+  if (exact && !isExact) {
+    return null;
+  }
+  return {
+    path,
+    url,
+    isExact
+  };
+};
+class HistoryRoute extends _Component.Component {
+  constructor(props) {
+    super(props);
+    this.handlePop = this.handlePop.bind(this);
+  }
+  componentDidMount() {
+    window.addEventListener("popstate", this.handlePop);
+    register(this);
+  }
+  componentWillUnmount() {
+    unregister(this);
+    window.removeEventListener("popstate", this.handlePop);
+  }
+  handlePop() {
+    this.setState();
+  }
+  render() {
+    const {
+      path,
+      exact,
+      component,
+      render
+    } = this.props;
+    const match = matchPath(window.location.pathname, {
+      path,
+      exact
+    });
+    if (match !== null) {
+      if (component) {
+        return (0, _elements.createElement)(component, {
+          match
+        });
+      }
+      if (render) {
+        return render({
+          match
+        });
+      }
+    }
+    return null;
+  }
+}
+class HistoryLink extends _Component.Component {
+  constructor(props) {
+    super(props);
+    this.handleClick = this.handleClick.bind(this);
+  }
+  handleClick(event) {
+    event.preventDefault();
+    const {
+      replace,
+      to
+    } = this.props;
+    replace ? historyReplace(to) : historyPush(to);
+  }
+  render() {
+    const {
+      to,
+      children,
+      ...restProps
+    } = this.props;
+    const {
+      ariaLabel
+    } = restProps;
+    return (0, _elements.createElement)('a', {
+      href: to,
+      ariaLabel: `historyLink${ariaLabel ? `-${ariaLabel}` : ''}`,
+      onClick: this.handleClick,
+      ...restProps
+    }, children);
+  }
+}
+class HistoryRedirect extends _Component.Component {
+  componentDidMount() {
+    const {
+      to,
+      push
+    } = this.props;
+    push ? historyPush(to) : historyReplace(to);
+  }
+  render() {
+    return null;
+  }
+}
+const goTo = (path = '/', replace) => {
+  replace ? historyReplace(path) : historyPush(path);
+};
+exports.goTo = goTo;
+const History = {
+  Link: HistoryLink,
+  Redirect: HistoryRedirect,
+  Route: HistoryRoute
+};
+var _default = exports.default = History;