anu-verzum 1.0.0

package/dist/core/components/Intl.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elements = require("../elements");
+var _Context = require("./Context");
+const _Intl = (0, _Context.createContext)({});
+let __messagesContext = {
+  locale: undefined,
+  messages: {}
+};
+const IntlProvider = ({
+  locale,
+  messages,
+  defaultLocale,
+  children
+}) => {
+  let selectedMessage;
+  try {
+    if (locale === null) {
+      throw new Error('Property "locale" must be defined and must not be a string reference to the selected language in "messages"!');
+    }
+    if (!messages) {
+      throw new Error('Property "messages" must be defined!');
+    }
+    if (messages[locale]) {
+      selectedMessage = messages[locale];
+    } else if (messages[defaultLocale]) {
+      selectedMessage = messages[defaultLocale];
+    }
+    if (!selectedMessage) {
+      throw new Error('No messages can be found in "messages" by the value of "locale" or "defaultLocale"!');
+    } else {
+      __messagesContext = {
+        locale,
+        messages: {
+          ...selectedMessage
+        }
+      };
+      return (0, _elements.createElement)(_Intl.ContextProvider, {
+        locale,
+        messages: selectedMessage
+      }, children);
+    }
+  } catch (err) {
+    console.error(err);
+  }
+};
+const FormattedMessage = ({
+  id,
+  values,
+  defaultMessage
+}) => (0, _elements.createElement)(_Intl.ContextConsumer, {}, ({
+  value: {
+    messages
+  }
+}) => {
+  let textValue = '';
+  try {
+    if (messages && messages[id]) {
+      textValue = messages[id];
+    } else if (defaultMessage) {
+      textValue = defaultMessage;
+    } else {
+      textValue = id;
+    }
+    if (textValue.length === 0) {
+      throw new Error('No text or fallback value to return.');
+    } else {
+      if (values && typeof values === 'object' && values !== null) {
+        Object.keys(values).forEach(key => {
+          const variablePattern = `{${key}}`;
+          if (textValue.indexOf(variablePattern) > -1) {
+            textValue = textValue.replace(variablePattern, values[key]);
+          }
+        });
+      }
+      return (0, _elements.createElement)(_elements.TEXT_ELEMENT, {
+        nodeValue: textValue
+      });
+    }
+  } catch (err) {
+    console.error(err);
+  }
+});
+const formatMessage = (id, values, defaultMessage) => {
+  let textValue = '';
+  try {
+    if (__messagesContext.messages[id]) {
+      textValue = __messagesContext.messages[id];
+    } else if (defaultMessage) {
+      textValue = defaultMessage;
+    } else {
+      textValue = id;
+    }
+    if (textValue.length === 0) {
+      throw new Error('No text or fallback value to return.');
+    }
+  } catch (err) {
+    console.error(err);
+  }
+  if (values && typeof values === 'object' && values !== null) {
+    Object.keys(values).forEach(key => {
+      const variablePattern = `{${key}}`;
+      if (textValue.indexOf(variablePattern) > -1) {
+        textValue = textValue.replace(variablePattern, values[key]);
+      }
+    });
+  }
+  return textValue;
+};
+const abbreviateNumber = (value, options = {}) => {
+  const getByLocale = values => values[__messagesContext.locale] || values['default'];
+  const UNITS = {
+    'hu': ['E', 'm', 'M', 'b'],
+    'default': ['K', 'M', 'B', 'T']
+  };
+  const DECIMAL_SIGN = {
+    'hu': ',',
+    'default': '.'
+  };
+  if (typeof value === 'number' && !isNaN(value)) {
+    const defaultAbbreviateNumberOptions = {
+      units: getByLocale(UNITS),
+      decimalPlaces: 2,
+      decimalSign: getByLocale(DECIMAL_SIGN)
+    };
+    const isNegative = value < 0;
+    const opts = {
+      ...defaultAbbreviateNumberOptions,
+      ...options
+    };
+    const {
+      units,
+      decimalPlaces,
+      decimalSign
+    } = opts;
+    const decPlaces = Math.pow(10, decimalPlaces);
+    let unit = '';
+    let result = Math.abs(value);
+    for (let i = units.length - 1; i >= 0; i--) {
+      const size = Math.pow(10, (i + 1) * 3);
+      if (size <= result) {
+        result = Math.round(result * decPlaces / size) / decPlaces;
+        if (result === 1000 && i < units.length - 1) {
+          result = 1;
+          i++;
+        }
+        unit = units[i];
+        break;
+      }
+    }
+    if (decimalSign) {
+      result = `${result}`.replace('.', decimalSign);
+    }
+    return `${isNegative ? '-' : ''}${result}${unit}`;
+  }
+  return value;
+};
+const Intl = {
+  abbreviateNumber,
+  FormattedMessage,
+  formatMessage,
+  Provider: IntlProvider
+};
+var _default = exports.default = Intl;

package/dist/core/domUtils.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateDomProperties = exports.createDomElement = exports.SVG_ELEMENT_LIST = void 0;
+var _elements = require("./elements");
+const getHTMLValidSvgTag = fiberType => {
+  switch (fiberType) {
+    case 'anchor':
+      {
+        return 'a';
+      }
+    case 'svgStyle':
+      {
+        return 'style';
+      }
+    case 'svgTitle':
+      {
+        return 'title';
+      }
+    default:
+      {
+        return fiberType;
+      }
+  }
+};
+const SVG_ELEMENT_LIST = exports.SVG_ELEMENT_LIST = ['anchor', 'animate', 'animateMotion', 'animateTransform', 'circle', 'clipPath', 'desc', 'discard', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence', 'filter', 'foreignObject', 'g', 'hatch', 'hatchpath', 'image', 'line', 'linearGradient', 'marker', 'mask', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'set', 'stop', 'svgStyle', 'svg', 'switch', 'symbol', 'text', 'textPath', 'svgTitle', 'tspan', 'unknown', 'use', 'view'];
+const updateDomProperties = (dom, prevProps, nextProps, isSvgElement = false) => {
+  const isEvent = name => {
+    if (!String.prototype.startsWith) {
+      return name[0] === 'o' && name[1] === 'n';
+    }
+    return name.startsWith('on');
+  };
+  const isAttribute = name => !isEvent(name) && name !== 'children' && name !== 'style' && name !== 'ref' && name !== 'key';
+  const isNew = (prev, next) => key => prev[key] !== next[key];
+  const isGone = (prev, next) => key => !(key in next);
+  Object.keys(prevProps).filter(isEvent).filter(key => !(key in nextProps) || isNew(prevProps, nextProps)(key)).forEach(name => {
+    const eventType = name.toLowerCase().substring(2);
+    dom.removeEventListener(eventType, prevProps[name]);
+  });
+  Object.keys(prevProps).filter(isAttribute).filter(isGone(prevProps, nextProps)).forEach(name => {
+    if (name === 'className') {
+      dom['class'] = null;
+    } else if (name === 'htmlFor') {
+      dom['for'] = null;
+    } else {
+      dom[name] = null;
+    }
+  });
+  Object.keys(nextProps).filter(isAttribute).filter(isNew(prevProps, nextProps)).forEach(name => {
+    if (isSvgElement) {
+      if (name === 'className') {
+        dom.setAttribute('class', nextProps[name]);
+      } else {
+        dom.setAttribute(name, nextProps[name]);
+      }
+    } else {
+      if (name.includes('aria-') || name === 'role') {
+        dom.setAttribute(name, nextProps[name]);
+      } else {
+        dom[name] = nextProps[name];
+      }
+    }
+  });
+  prevProps.style = prevProps.style || {};
+  nextProps.style = nextProps.style || {};
+  Object.keys(nextProps.style).filter(isNew(prevProps.style, nextProps.style)).forEach(key => {
+    dom.style[key] = nextProps.style[key];
+  });
+  Object.keys(prevProps.style).filter(isGone(prevProps.style, nextProps.style)).forEach(key => {
+    dom.style[key] = '';
+  });
+  Object.keys(nextProps).filter(isEvent).filter(isNew(prevProps, nextProps)).forEach(name => {
+    const eventType = name.toLowerCase().substring(2);
+    dom.addEventListener(eventType, nextProps[name]);
+  });
+};
+exports.updateDomProperties = updateDomProperties;
+const createDomElement = fiber => {
+  const isTextElement = fiber.type === _elements.TEXT_ELEMENT;
+  const isSvgElement = SVG_ELEMENT_LIST.indexOf(fiber.type) > -1;
+  let dom;
+  if (isTextElement) {
+    dom = document.createTextNode('');
+  } else if (isSvgElement) {
+    dom = document.createElementNS('http://www.w3.org/2000/svg', getHTMLValidSvgTag(fiber.type));
+  } else {
+    dom = document.createElement(fiber.type);
+  }
+  updateDomProperties(dom, {}, fiber.props, isSvgElement);
+  return dom;
+};
+exports.createDomElement = createDomElement;

package/dist/core/elements.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElement = exports.TEXT_ELEMENT = void 0;
+const TEXT_ELEMENT = exports.TEXT_ELEMENT = 'TEXT_ELEMENT';
+const createTextElement = value => ({
+  type: TEXT_ELEMENT,
+  props: {
+    nodeValue: value
+  }
+});
+const createElement = (type, config, ...args) => {
+  const props = Object.assign({}, config);
+  const hasChildren = args.length > 0;
+  const rawChildren = hasChildren ? [].concat(...args) : [];
+  props.children = rawChildren.filter(c => c !== null && c !== false).map(c => typeof c === 'function' ? createElement(c, {
+    ...(c.props || {})
+  }) : c instanceof Object ? c : createTextElement(c));
+  return {
+    type,
+    props
+  };
+};
+exports.createElement = createElement;

package/dist/core/reconciler.js

@@ -0,0 +1,379 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scheduleUpdate = exports.render = exports.createRef = void 0;
+var _domUtils = require("./domUtils");
+const HOST_COMPONENT = 'host';
+const CLASS_COMPONENT = 'class';
+const FUNCTION_COMPONENT = 'function';
+const HOST_ROOT = 'root';
+const PLACEMENT = 1;
+const DELETION = 2;
+const UPDATE = 3;
+const ENOUGH_TIME = 1;
+const updateQueue = [];
+let nextUnitOfWork = null;
+let pendingCommit = null;
+const getRoot = fiber => {
+  let node = fiber;
+  while (node.parent) {
+    node = node.parent;
+  }
+  return node;
+};
+const resetNextUnitOfWork = () => {
+  const update = updateQueue.shift();
+  if (!update) {
+    return;
+  }
+  if (update.partialState) {
+    update.instance.__fiber.partialState = update.partialState;
+  }
+  if (update.partialStateCallback) {
+    update.instance.__fiber.partialStateCallback = update.partialStateCallback;
+  }
+  const root = update.from === HOST_ROOT ? update.dom._rootContainerFiber : getRoot(update.instance.__fiber);
+  nextUnitOfWork = {
+    tag: HOST_ROOT,
+    stateNode: update.dom || root.stateNode,
+    props: update.newProps || root.props,
+    alternate: root
+  };
+};
+const workLoop = deadline => {
+  if (!nextUnitOfWork) {
+    resetNextUnitOfWork();
+  }
+  while (nextUnitOfWork && deadline.timeRemaining() > ENOUGH_TIME) {
+    nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+  }
+  if (pendingCommit) {
+    commitAllWork(pendingCommit);
+  }
+};
+const performWork = deadline => {
+  workLoop(deadline);
+  if (nextUnitOfWork || updateQueue.length > 0) {
+    requestIdleCallback(performWork);
+  }
+};
+const performUnitOfWork = wipFiber => {
+  beginWork(wipFiber);
+  if (wipFiber.child) {
+    return wipFiber.child;
+  }
+  let unitOfWork = wipFiber;
+  while (unitOfWork) {
+    completeWork(unitOfWork);
+    if (unitOfWork.sibling) {
+      return unitOfWork.sibling;
+    }
+    unitOfWork = unitOfWork.parent;
+  }
+};
+const beginWork = wipFiber => {
+  if (wipFiber.tag === CLASS_COMPONENT) {
+    updateClassComponent(wipFiber);
+  } else if (wipFiber.tag === FUNCTION_COMPONENT) {
+    updateFunctionComponent(wipFiber);
+  } else {
+    updateHostComponent(wipFiber);
+  }
+};
+const updateHostComponent = wipFiber => {
+  if (!wipFiber.stateNode) {
+    wipFiber.stateNode = (0, _domUtils.createDomElement)(wipFiber);
+  }
+  const newChildElements = wipFiber.props.children;
+  reconcileChildrenArray(wipFiber, newChildElements);
+};
+const createFunctionComponent = fiber => {
+  const instance = fiber.type(fiber.props);
+  instance.__fiber = fiber;
+  return instance;
+};
+const updateFunctionComponent = wipFiber => {
+  let instance = wipFiber.stateNode || null;
+  if (instance === null) {
+    instance = wipFiber.stateNode = createFunctionComponent(wipFiber);
+  } else if (wipFiber.props === instance.props && !wipFiber.partialState) {
+    cloneChildFibers(wipFiber);
+    return;
+  }
+  instance.props = wipFiber.props;
+  wipFiber.stateNode.render = wipFiber.type;
+  const newChildElements = wipFiber.stateNode.render(wipFiber.props);
+  reconcileChildrenArray(wipFiber, newChildElements);
+};
+const createInstance = fiber => {
+  const context = Object.assign({}, fiber.stateNode ? {
+    ...fiber.stateNode.context
+  } : {});
+  const instance = new fiber.type(fiber.props, context);
+  instance.__fiber = fiber;
+  return instance;
+};
+const updateClassComponent = wipFiber => {
+  let instance = wipFiber.stateNode || null;
+  if (instance === null) {
+    const stateNode = createInstance(wipFiber);
+    stateNode.context = {
+      ...stateNode.context
+    };
+    instance = wipFiber.stateNode = stateNode;
+    wipFiber.stateNode.setState = wipFiber.stateNode.setState.bind(wipFiber.stateNode);
+    if (wipFiber.type.prototype.componentDidMount) {
+      wipFiber.stateNode.componentDidMount = wipFiber.stateNode.componentDidMount.bind(wipFiber.stateNode);
+    }
+    if (wipFiber.type.prototype.componentDidUpdate) {
+      wipFiber.stateNode.componentDidUpdate = wipFiber.stateNode.componentDidUpdate.bind(wipFiber.stateNode);
+    }
+    if (wipFiber.type.prototype.componentWillUnmount) {
+      wipFiber.stateNode.componentWillUnmount = wipFiber.stateNode.componentWillUnmount.bind(wipFiber.stateNode);
+    }
+  } else if (wipFiber.props === instance.props && !wipFiber.partialState && !wipFiber.partialStateCallback) {
+    cloneChildFibers(wipFiber);
+    return;
+  }
+  const nextProps = {
+    ...wipFiber.props
+  };
+  let nextState = {};
+  if (!wipFiber.partialStateCallback) {
+    nextState = Object.assign({}, instance.state, wipFiber.partialState);
+  } else {
+    nextState = wipFiber.partialStateCallback(instance.state, nextProps);
+  }
+  instance.props = nextProps;
+  instance.state = nextState;
+  wipFiber.partialState = null;
+  delete wipFiber.partialStateCallback;
+  let newChildElements = null;
+  newChildElements = wipFiber.stateNode.render();
+  reconcileChildrenArray(wipFiber, newChildElements);
+};
+const arrify = val => !val ? [] : Array.isArray(val) ? val : [val];
+const reconcileChildrenArray = (wipFiber, newChildElements) => {
+  const elements = arrify(newChildElements);
+  let index = 0;
+  let oldFiber = wipFiber.alternate ? wipFiber.alternate.child : null;
+  let newFiber = null;
+  while (index < elements.length || oldFiber) {
+    const prevFiber = newFiber;
+    const element = index < elements.length && elements[index];
+    const sameType = oldFiber && element && element.type === oldFiber.type;
+    if (sameType) {
+      newFiber = {
+        type: oldFiber.type,
+        tag: oldFiber.tag,
+        stateNode: oldFiber.stateNode,
+        props: element.props,
+        parent: wipFiber,
+        alternate: oldFiber,
+        partialState: oldFiber.partialState,
+        effectTag: UPDATE
+      };
+      if (oldFiber.partialStateCallback) {
+        newFiber.partialStateCallback = oldFiber.partialStateCallback;
+      }
+    }
+    if (element && !sameType) {
+      let tag;
+      if (typeof element.type === 'string') {
+        tag = HOST_COMPONENT;
+      } else if (typeof element.type === 'function' && !element.type.isAnuComponent && !element.type.prototype.hasOwnProperty('render')) {
+        tag = FUNCTION_COMPONENT;
+      } else {
+        tag = CLASS_COMPONENT;
+      }
+      newFiber = {
+        type: element.type,
+        tag,
+        props: element.props,
+        parent: wipFiber,
+        effectTag: PLACEMENT
+      };
+    }
+    if (oldFiber && !sameType) {
+      oldFiber.effectTag = DELETION;
+      wipFiber.effects = wipFiber.effects || [];
+      wipFiber.effects.push(oldFiber);
+    }
+    if (oldFiber) {
+      oldFiber = oldFiber.sibling;
+    }
+    if (index === 0) {
+      wipFiber.child = newFiber;
+    } else if (prevFiber && element) {
+      prevFiber.sibling = newFiber;
+    }
+    index++;
+  }
+};
+const cloneChildFibers = parentFiber => {
+  const oldFiber = parentFiber.alternate;
+  if (!oldFiber.child) {
+    return;
+  }
+  let oldChild = oldFiber.child;
+  let prevChild = null;
+  while (oldChild) {
+    const newChild = {
+      type: oldChild.type,
+      tag: oldChild.tag,
+      stateNode: oldChild.stateNode,
+      props: oldChild.props,
+      partialState: oldChild.partialState,
+      alternate: oldChild,
+      parent: parentFiber
+    };
+    if (oldChild.partialStateCallback) {
+      newChild.partialStateCallback = oldChild.partialStateCallback;
+    }
+    if (prevChild) {
+      prevChild.sibling = newChild;
+    } else {
+      parentFiber.child = newChild;
+    }
+    prevChild = newChild;
+    oldChild = oldChild.sibling;
+  }
+};
+const completeWork = fiber => {
+  if (fiber.tag === CLASS_COMPONENT) {
+    fiber.stateNode.__fiber = fiber;
+  }
+  if (fiber.parent) {
+    const childEffects = fiber.effects || [];
+    const thisEffect = fiber.effectTag !== null ? [fiber] : [];
+    const parentEffects = fiber.parent.effects || [];
+    fiber.parent.effects = parentEffects.concat(childEffects, thisEffect);
+  } else {
+    pendingCommit = fiber;
+  }
+};
+const componentLifecyclesQueue = [];
+const flushComponentLifecyclesQueue = () => {
+  while (componentLifecyclesQueue.length > 0) {
+    const {
+      fn,
+      params: {
+        prevProps,
+        prevState
+      }
+    } = componentLifecyclesQueue.shift();
+    fn(prevProps, prevState);
+  }
+};
+const commitAllWork = fiber => {
+  fiber.effects.forEach((effect, index, effects) => {
+    commitWork(effect);
+    if (index === effects.length - 1) {
+      flushComponentLifecyclesQueue();
+    }
+  });
+  fiber.stateNode._rootContainerFiber = fiber;
+  nextUnitOfWork = null;
+  pendingCommit = null;
+};
+const commitWork = effect => {
+  if (effect.tag === HOST_ROOT) {
+    return;
+  }
+  let domParentFiber = effect.parent;
+  const isRefInProps = props => Object.keys(props).indexOf('ref') > -1;
+  while (domParentFiber.tag === CLASS_COMPONENT || domParentFiber.tag === FUNCTION_COMPONENT) {
+    domParentFiber = domParentFiber.parent;
+  }
+  const domParent = domParentFiber.stateNode;
+  if (effect.effectTag === PLACEMENT) {
+    if (effect.tag === HOST_COMPONENT) {
+      domParent.appendChild(effect.stateNode);
+      if (isRefInProps(effect.props)) {
+        effect.props.ref.current = effect.stateNode;
+      }
+    } else if (effect.tag === CLASS_COMPONENT) {
+      if (effect.stateNode.componentDidMount) {
+        componentLifecyclesQueue.push({
+          fn: effect.stateNode.componentDidMount,
+          params: {}
+        });
+      }
+    }
+  } else if (effect.effectTag === UPDATE) {
+    if (effect && effect.stateNode && effect.alternate && effect.alternate.props && effect.props) {
+      if (effect.tag === HOST_COMPONENT) {
+        (0, _domUtils.updateDomProperties)(effect.stateNode, effect.alternate.props, effect.props, _domUtils.SVG_ELEMENT_LIST.indexOf(effect.type) > -1);
+        if (isRefInProps(effect.props)) {
+          effect.props.ref.current = effect.stateNode;
+        }
+      } else if (effect.tag === CLASS_COMPONENT) {
+        if (effect.stateNode.componentDidUpdate) {
+          componentLifecyclesQueue.push({
+            fn: effect.stateNode.componentDidUpdate,
+            params: {
+              prevProps: effect.stateNode.props,
+              prevState: effect.stateNode.state
+            }
+          });
+        }
+      }
+    }
+  } else if (effect.effectTag === DELETION) {
+    if (effect.tag === CLASS_COMPONENT) {
+      if (effect.stateNode.componentWillUnmount) {
+        effect.stateNode.componentWillUnmount();
+      }
+    }
+    commitDeletion(effect, domParent);
+  }
+};
+const commitDeletion = (fiber, domParent) => {
+  let node = fiber;
+  while (node) {
+    if (node.tag === CLASS_COMPONENT || node.tag === FUNCTION_COMPONENT) {
+      node = node.child;
+      continue;
+    }
+    if (domParent.contains(node.stateNode)) {
+      domParent.removeChild(node.stateNode);
+    }
+    while (node !== fiber && !node.sibling) {
+      node = node.parent;
+    }
+    if (node === fiber) {
+      return;
+    }
+    node = node.sibling;
+  }
+};
+const createRef = () => ({
+  current: null
+});
+exports.createRef = createRef;
+const scheduleUpdate = (instance, partialState, partialStateCallback) => {
+  const updateFiber = {
+    from: CLASS_COMPONENT,
+    instance,
+    partialState
+  };
+  if (partialStateCallback) {
+    updateFiber.partialStateCallback = partialStateCallback;
+  }
+  updateQueue.push(updateFiber);
+  requestIdleCallback(performWork);
+};
+exports.scheduleUpdate = scheduleUpdate;
+const render = (elements, containerDom) => {
+  updateQueue.push({
+    from: HOST_ROOT,
+    dom: containerDom,
+    newProps: {
+      children: elements
+    }
+  });
+  requestIdleCallback(performWork);
+};
+exports.render = render;