@semcore/core 2.40.0-prerelease.1 → 2.40.0-prerelease.5

package/lib/esm/styled/sstyled.mjs

@@ -0,0 +1,125 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _cn from "classnames";
+import { getStyles as getStyles$1 } from "./reshadow-core.mjs";
+var RESHADOW_ID = "__reshadow__";
+var isSSR = !(typeof window !== "undefined" && window.document && window.document.createElement);
+var serverMap = getStyles$1().map;
+var getStyles = function getStyles2() {
+  return {
+    map: serverMap,
+    get css() {
+      var serverStyles = "";
+      for (var id in serverMap) {
+        serverStyles += "<style type='text/css' id='".concat(id, "'>").concat(serverMap[id], "</style>");
+      }
+      return serverStyles;
+    }
+  };
+};
+function insert(code, hash) {
+  var id = "reshadow-".concat(hash);
+  if (isSSR) {
+    serverMap[id] = code;
+    return;
+  }
+  var container = document.getElementById(RESHADOW_ID);
+  if (!container) {
+    container = document.createElement("object");
+    container.id = RESHADOW_ID;
+    if (document.head) {
+      document.head.appendChild(container);
+    } else {
+      document.addEventListener("DOMContentLoaded", function() {
+        document.head.appendChild(container);
+      });
+    }
+  }
+  var css = document.getElementById(id);
+  if (!css) {
+    css = document.createElement("style");
+    css.id = id;
+    css.type = "text/css";
+    container.appendChild(css);
+  }
+  css.innerHTML = code;
+}
+function merge() {
+  var s1 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var s2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  return Object.entries(s2).reduce(function(acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1];
+    if (key.startsWith("@") || key.startsWith("--")) {
+      acc[key] = value;
+    } else {
+      acc[key] = _cn(acc[key], value);
+    }
+    return acc;
+  }, Object.assign({}, s1));
+}
+function getClassAndVars(styles, name, props) {
+  function getPropValue(key, props2) {
+    var _props;
+    return (_props = props2["use:".concat(key)]) !== null && _props !== void 0 ? _props : props2[key];
+  }
+  return Object.entries(styles).reduce(function(acc, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2), key = _ref4[0], value = _ref4[1];
+    if (key.startsWith("--")) {
+      acc[1][value] = getPropValue(key.substring(2), props);
+    } else if (name === key) {
+      acc[0][value] = true;
+    } else {
+      var _key$split = key.split("="), _key$split2 = _slicedToArray(_key$split, 2), mod = _key$split2[0], modValue = _key$split2[1];
+      var propValue = getPropValue(mod, props);
+      if (modValue === void 0) {
+        acc[0][value] = Boolean(propValue !== null && propValue !== void 0 ? propValue : false);
+      } else {
+        acc[0][value] = propValue == modValue;
+      }
+    }
+    return acc;
+  }, [{}, {}]);
+}
+var reshadowMap = /* @__PURE__ */ new WeakMap();
+function reshadowToShadow(obj) {
+  if (reshadowMap.has(obj)) {
+    return reshadowMap.get(obj);
+  }
+  var shadowStyle = Object.entries(obj).reduce(function(style, _ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2), name = _ref6[0], value = _ref6[1];
+    var n = name;
+    if (name.startsWith("__")) {
+      n = name.replace(/^__/, "");
+    } else if (name.startsWith("_")) {
+      n = name.replace(/^_/, "").replace("_", "=");
+    }
+    style[n] = value;
+    return style;
+  }, {});
+  reshadowMap.set(obj, shadowStyle);
+  return shadowStyle;
+}
+function sstyled() {
+  var styles = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  return {
+    cn: function cn(name, props) {
+      var _getClassAndVars = getClassAndVars(reshadowToShadow(styles), name, props), _getClassAndVars2 = _slicedToArray(_getClassAndVars, 2), classes = _getClassAndVars2[0], style = _getClassAndVars2[1];
+      if (Object.keys(classes).length) {
+        props.className = _cn(props.className, classes);
+      }
+      if (Object.keys(style).length) {
+        props.style = Object.assign(style, props.style);
+      }
+      return props;
+    }
+  };
+}
+sstyled.css = function(_css) {
+  throw new Error("Enable babel plugin");
+};
+sstyled.insert = insert;
+sstyled.merge = merge;
+sstyled.getStyles = getStyles;
+sstyled.SHADOW_STYLES = /* @__PURE__ */ Symbol("SHADOW_STYLES");
+export {
+  sstyled
+};

package/lib/esm/utils/assignProps.mjs

@@ -0,0 +1,86 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _cn from "classnames";
+import { forkRef } from "./ref.mjs";
+import "../styled/index.mjs";
+import { sstyled } from "../styled/sstyled.mjs";
+function callAllEventHandlers() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return !fns.some(function(fn) {
+      var result;
+      if (fn) {
+        result = fn.apply(void 0, args);
+      }
+      return typeof result === "boolean" && !result;
+    });
+  };
+}
+function assignHandlers(props, source) {
+  return Object.keys(source).reduce(function(proxySource, propName) {
+    if (typeof source[propName] === "function" && propName.startsWith("on")) {
+      proxySource[propName] = callAllEventHandlers(props[propName], source[propName]);
+    }
+    return proxySource;
+  }, {});
+}
+function assignHandlersInner(props, source) {
+  return Object.keys(source).reduce(function(proxySource, propName) {
+    if (propName !== "ref" && propName.startsWith("on")) {
+      if (typeof source[propName] === "function" && typeof props[propName] === "function") {
+        proxySource[propName] = callAllEventHandlers(props[propName], source[propName]);
+      } else if (typeof source[propName] === "function") {
+        proxySource[propName] = source[propName];
+      } else if (typeof props[propName] === "function") {
+        proxySource[propName] = props[propName];
+      }
+    }
+    return proxySource;
+  }, {});
+}
+function assignProps() {
+  var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var source = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  if (props === source) return props;
+  var newProps = _objectSpread(_objectSpread(_objectSpread({}, source), props), assignHandlersInner(props, source));
+  for (var _key3 in source) {
+    if (_key3.startsWith("use:")) {
+      var originalKey = _key3.slice("use:".length);
+      newProps[originalKey] = source[_key3];
+    }
+  }
+  for (var _key4 in props) {
+    if (_key4.startsWith("use:")) {
+      var _originalKey = _key4.slice("use:".length);
+      newProps[_originalKey] = props[_key4];
+    }
+  }
+  var sourceDescriptorRef = Object.getOwnPropertyDescriptor(source, "ref");
+  var propsDescriptorRef = Object.getOwnPropertyDescriptor(props, "ref");
+  if (sourceDescriptorRef !== null && sourceDescriptorRef !== void 0 && sourceDescriptorRef.configurable && propsDescriptorRef !== null && propsDescriptorRef !== void 0 && propsDescriptorRef.configurable) {
+    newProps.ref = forkRef(source.ref, props.ref);
+  }
+  if (props.forwardRef) {
+    newProps.ref = forkRef(newProps.ref, props.forwardRef);
+    newProps.forwardRef = newProps.ref;
+  }
+  if (source.style && props.style) {
+    newProps.style = _objectSpread(_objectSpread({}, source.style), props.style);
+  }
+  if (source.className) {
+    newProps.className = _cn(props.className, source.className);
+  }
+  if (source.styles && props.styles) {
+    newProps.styles = sstyled.merge(source.styles, props.styles);
+  }
+  return newProps;
+}
+export {
+  assignHandlers,
+  callAllEventHandlers,
+  assignProps as default
+};

package/lib/esm/utils/canUseDOM.mjs

@@ -0,0 +1,6 @@
+function canUseDOM() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+}
+export {
+  canUseDOM as default
+};

package/lib/esm/utils/capitalizeFirstLetter.mjs

@@ -0,0 +1,6 @@
+function capitalizeFirstLetter(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+export {
+  capitalizeFirstLetter as default
+};

package/lib/esm/utils/enhances/WithI18n.mjs

@@ -0,0 +1,30 @@
+import { createIntlCache, createIntl } from "@formatjs/intl";
+import React, { createContext } from "react";
+import { useAsyncI18nMessages } from "./i18nEnhance.mjs";
+var Context = /* @__PURE__ */ createContext(void 0);
+var I18nProvider = Context.Provider, I18nConsumer = Context.Consumer;
+var messagesCache = createIntlCache();
+var useI18n = function useI18n2(dictionary) {
+  var _React$useContext;
+  var locale = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "en";
+  var fallbackDictionary = arguments.length > 2 ? arguments[2] : void 0;
+  var lang = (_React$useContext = React.useContext(Context)) !== null && _React$useContext !== void 0 ? _React$useContext : locale;
+  var resolvedDictionary = useAsyncI18nMessages(dictionary, lang, fallbackDictionary);
+  var intl = React.useMemo(function() {
+    return createIntl({
+      locale: lang,
+      messages: resolvedDictionary
+    }, messagesCache);
+  }, [resolvedDictionary, lang]);
+  return React.useCallback(function(messageId, variables) {
+    return intl.formatMessage({
+      id: messageId !== null && messageId !== void 0 ? messageId : ""
+    }, variables);
+  }, [intl]);
+};
+export {
+  Context,
+  I18nConsumer,
+  I18nProvider,
+  useI18n
+};

package/lib/esm/utils/enhances/i18nEnhance.mjs

@@ -0,0 +1,90 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import React from "react";
+import { useI18n } from "./WithI18n.mjs";
+var useAsyncI18nMessages = function useAsyncI18nMessages2(primaryContainer, locale, fallbackContainer) {
+  var _store$locale;
+  var container = React.useMemo(function() {
+    if (!fallbackContainer) return primaryContainer;
+    if (!primaryContainer) return fallbackContainer;
+    if (primaryContainer === fallbackContainer) return primaryContainer;
+    var container2 = {};
+    var _loop = function _loop2(_locale2) {
+      if (typeof primaryContainer[_locale2] === "function" || typeof fallbackContainer[_locale2] === "function") {
+        container2[_locale2] = /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
+          var _yield$Promise$all, _yield$Promise$all2, primary, fallback;
+          return _regenerator().w(function(_context) {
+            while (1) switch (_context.n) {
+              case 0:
+                _context.n = 1;
+                return Promise.all([primaryContainer[_locale2], fallbackContainer[_locale2]]);
+              case 1:
+                _yield$Promise$all = _context.v;
+                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+                primary = _yield$Promise$all2[0];
+                fallback = _yield$Promise$all2[1];
+                return _context.a(2, _objectSpread(_objectSpread({}, primary), fallback));
+            }
+          }, _callee);
+        }));
+      } else {
+        var _primaryContainer$_lo, _fallbackContainer$_l;
+        container2[_locale2] = _objectSpread(_objectSpread({}, (_primaryContainer$_lo = primaryContainer[_locale2]) !== null && _primaryContainer$_lo !== void 0 ? _primaryContainer$_lo : {}), (_fallbackContainer$_l = fallbackContainer[_locale2]) !== null && _fallbackContainer$_l !== void 0 ? _fallbackContainer$_l : {});
+      }
+    };
+    for (var _locale in primaryContainer) {
+      _loop(_locale);
+    }
+    return container2;
+  }, [primaryContainer, fallbackContainer]);
+  var initStore = React.useMemo(function() {
+    var store2 = {};
+    for (var _locale2 in container) {
+      if (_typeof(container[_locale2]) === "object") {
+        store2[_locale2] = container[_locale2];
+      }
+    }
+    return store2;
+  }, [container]);
+  var _React$useState = React.useState(initStore), _React$useState2 = _slicedToArray(_React$useState, 2), store = _React$useState2[0], setStore = _React$useState2[1];
+  var lastLoadedLocaleRef = React.useRef(null);
+  if (store[locale]) lastLoadedLocaleRef.current = locale;
+  var fallbackMessages = React.useMemo(function() {
+    return Object.values(store)[0];
+  }, [store]);
+  var loadingLocaleRef = React.useRef(null);
+  React.useEffect(function() {
+    loadingLocaleRef.current = locale;
+    var asyncMessages = container[locale];
+    if (typeof asyncMessages === "function") {
+      asyncMessages().then(function(module) {
+        if (loadingLocaleRef.current !== locale) return;
+        var messages = module;
+        if ("default" in module && _typeof(module["default"]) === "object") messages = module["default"];
+        setStore(function(store2) {
+          return _objectSpread(_objectSpread({}, store2), {}, _defineProperty({}, locale, messages));
+        });
+      })["catch"](function(err) {
+        console.error(err);
+      });
+    }
+  }, [container, locale]);
+  return (_store$locale = store[locale]) !== null && _store$locale !== void 0 ? _store$locale : fallbackMessages;
+};
+const i18nEnhance = (function(container) {
+  return function(props) {
+    var i18n = props.i18n, locale = props.locale;
+    var getI18nText = useI18n(i18n, locale, container);
+    return _objectSpread(_objectSpread({}, props), {}, {
+      getI18nText
+    });
+  };
+});
+export {
+  i18nEnhance as default,
+  useAsyncI18nMessages
+};

package/lib/esm/utils/logger.mjs

@@ -0,0 +1,34 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var DEV = process.env.NODE_ENV !== "production";
+var Logger = /* @__PURE__ */ (function() {
+  function Logger2(logger2) {
+    _classCallCheck(this, Logger2);
+    _defineProperty(this, "logger", void 0);
+    this.logger = logger2 || {
+      warn: function warn() {
+      }
+    };
+  }
+  return _createClass(Logger2, [{
+    key: "console",
+    value: function console2(level, msg, component) {
+      this.logger[level](component ? "[".concat(component, "]: ").concat(msg) : msg);
+    }
+  }, {
+    key: "warn",
+    value: function warn(condition, msg, component) {
+      if (DEV) {
+        if (condition) {
+          this.console("warn", msg, component);
+        }
+      }
+    }
+  }]);
+})();
+const logger = new Logger(console);
+export {
+  Logger,
+  logger as default
+};

package/lib/esm/utils/pick.mjs

@@ -0,0 +1,15 @@
+function pick(obj, keys) {
+  var res = {};
+  var len = keys.length;
+  var idx = -1;
+  while (++idx < len) {
+    var key = keys[idx];
+    if (key in obj) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+export {
+  pick as default
+};

package/lib/esm/utils/ref.mjs

@@ -0,0 +1,73 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref !== null && ref !== void 0 && ref.hasOwnProperty("current")) {
+    ref["current"] = value;
+  }
+}
+function getRef(ref) {
+  if (!ref) return null;
+  return "current" in ref ? ref.current : ref;
+}
+function useCallbackRef(initialValue, callback) {
+  var _React$useState = React.useState(function() {
+    return {
+      // value
+      value: initialValue,
+      // last callback
+      callback,
+      // "memoized" public interface
+      facade: {
+        get current() {
+          return ref.value;
+        },
+        set current(value) {
+          var last = ref.value;
+          if (last !== value) {
+            ref.value = value;
+            ref.callback(value, last);
+          }
+        }
+      }
+    };
+  }), _React$useState2 = _slicedToArray(_React$useState, 1), ref = _React$useState2[0];
+  ref.callback = callback;
+  return ref.facade;
+}
+function useForkRef() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  return React.useCallback(function(refValue) {
+    var uniqueRefs = _toConsumableArray(new Set(refs));
+    uniqueRefs.forEach(function(ref) {
+      return setRef(ref, refValue);
+    });
+  }, refs);
+}
+function forkRef() {
+  for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    refs[_key2] = arguments[_key2];
+  }
+  if (refs.every(function(ref) {
+    return ref == null;
+  })) {
+    return null;
+  }
+  return function(refValue) {
+    var uniqueRefs = _toConsumableArray(new Set(refs));
+    uniqueRefs.forEach(function(ref) {
+      return setRef(ref, refValue);
+    });
+  };
+}
+export {
+  forkRef,
+  getRef,
+  setRef,
+  useCallbackRef,
+  useForkRef
+};

package/lib/esm/utils/use/useEnhancedEffect.mjs

@@ -0,0 +1,6 @@
+import React from "react";
+import canUseDOM from "../canUseDOM.mjs";
+var useEnhancedEffect = canUseDOM() ? React.useLayoutEffect : React.useEffect;
+export {
+  useEnhancedEffect as default
+};

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+/** ============================== core ============================== */
+import { Root, Component, Intergalactic, wrapIntergalacticComponent } from './core-types/Component';
+import type { PropGetterFn, IRootComponentProps, IRootNodeProps } from './core-types/Component';
+import { CORE_INSTANCE, CREATE_COMPONENT, CONTEXT_COMPONENT, CHILDREN_COMPONENT, INHERITED_NAME } from './core-types/symbols';
+import type { UnknownProperties } from './core-types/UnknownProperties';
+import { createComponent, createBaseComponent, assignProps } from './coreFactory';
+import { lastInteraction } from './LastInteractionType';
+import register from './register';
+import type { IStyledProps } from './styled';
+import { sstyled } from './styled';
+export { sstyled, createComponent, createBaseComponent, Root, Component, type UnknownProperties, Intergalactic, type PropGetterFn, type IRootComponentProps, type IRootNodeProps, CORE_INSTANCE, CREATE_COMPONENT, CONTEXT_COMPONENT, CHILDREN_COMPONENT, INHERITED_NAME, type IStyledProps, wrapIntergalacticComponent, assignProps, register, lastInteraction, };

package/lib/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CHILDREN_COMPONENT", {
+  enumerable: true,
+  get: function get() {
+    return _symbols.CHILDREN_COMPONENT;
+  }
+});
+Object.defineProperty(exports, "CONTEXT_COMPONENT", {
+  enumerable: true,
+  get: function get() {
+    return _symbols.CONTEXT_COMPONENT;
+  }
+});
+Object.defineProperty(exports, "CORE_INSTANCE", {
+  enumerable: true,
+  get: function get() {
+    return _symbols.CORE_INSTANCE;
+  }
+});
+Object.defineProperty(exports, "CREATE_COMPONENT", {
+  enumerable: true,
+  get: function get() {
+    return _symbols.CREATE_COMPONENT;
+  }
+});
+Object.defineProperty(exports, "Component", {
+  enumerable: true,
+  get: function get() {
+    return _Component.Component;
+  }
+});
+Object.defineProperty(exports, "INHERITED_NAME", {
+  enumerable: true,
+  get: function get() {
+    return _symbols.INHERITED_NAME;
+  }
+});
+Object.defineProperty(exports, "Intergalactic", {
+  enumerable: true,
+  get: function get() {
+    return _Component.Intergalactic;
+  }
+});
+Object.defineProperty(exports, "Root", {
+  enumerable: true,
+  get: function get() {
+    return _Component.Root;
+  }
+});
+Object.defineProperty(exports, "assignProps", {
+  enumerable: true,
+  get: function get() {
+    return _coreFactory.assignProps;
+  }
+});
+Object.defineProperty(exports, "createBaseComponent", {
+  enumerable: true,
+  get: function get() {
+    return _coreFactory.createBaseComponent;
+  }
+});
+Object.defineProperty(exports, "createComponent", {
+  enumerable: true,
+  get: function get() {
+    return _coreFactory.createComponent;
+  }
+});
+Object.defineProperty(exports, "lastInteraction", {
+  enumerable: true,
+  get: function get() {
+    return _LastInteractionType.lastInteraction;
+  }
+});
+Object.defineProperty(exports, "register", {
+  enumerable: true,
+  get: function get() {
+    return _register["default"];
+  }
+});
+Object.defineProperty(exports, "sstyled", {
+  enumerable: true,
+  get: function get() {
+    return _styled.sstyled;
+  }
+});
+Object.defineProperty(exports, "wrapIntergalacticComponent", {
+  enumerable: true,
+  get: function get() {
+    return _Component.wrapIntergalacticComponent;
+  }
+});
+var _Component = require("./core-types/Component");
+var _symbols = require("./core-types/symbols");
+var _coreFactory = require("./coreFactory");
+var _LastInteractionType = require("./LastInteractionType");
+var _register = _interopRequireDefault(require("./register"));
+var _styled = require("./styled");
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_Component","require","_symbols","_coreFactory","_LastInteractionType","_register","_interopRequireDefault","_styled"],"sources":["../src/index.ts"],"sourcesContent":["/** ============================== core ============================== */\nimport { Root, Component, Intergalactic, wrapIntergalacticComponent } from './core-types/Component';\nimport type {\n  PropGetterFn,\n  IRootComponentProps,\n  IRootNodeProps,\n} from './core-types/Component';\nimport {\n  CORE_INSTANCE,\n  CREATE_COMPONENT,\n  CONTEXT_COMPONENT,\n  CHILDREN_COMPONENT,\n  INHERITED_NAME,\n} from './core-types/symbols';\nimport type { UnknownProperties } from './core-types/UnknownProperties';\nimport { createComponent, createBaseComponent, assignProps } from './coreFactory';\nimport { lastInteraction } from './LastInteractionType';\nimport register from './register';\nimport type { IStyledProps } from './styled';\nimport { sstyled } from './styled';\n\nexport {\n  sstyled,\n  createComponent,\n  createBaseComponent,\n  Root,\n  Component,\n  type UnknownProperties,\n  Intergalactic,\n  type PropGetterFn,\n  type IRootComponentProps,\n  type IRootNodeProps,\n  CORE_INSTANCE,\n  CREATE_COMPONENT,\n  CONTEXT_COMPONENT,\n  CHILDREN_COMPONENT,\n  INHERITED_NAME,\n  type IStyledProps,\n  wrapIntergalacticComponent,\n  assignProps,\n  register,\n  lastInteraction,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA;AAMA,IAAAC,QAAA,GAAAD,OAAA;AAQA,IAAAE,YAAA,GAAAF,OAAA;AACA,IAAAG,oBAAA,GAAAH,OAAA;AACA,IAAAI,SAAA,GAAAC,sBAAA,CAAAL,OAAA;AAEA,IAAAM,OAAA,GAAAN,OAAA","ignoreList":[]}

package/lib/index.mjs

@@ -0,0 +1,24 @@
+import { Component, Intergalactic, Root, wrapIntergalacticComponent } from "./core-types/Component.mjs";
+import { CHILDREN_COMPONENT, CONTEXT_COMPONENT, CORE_INSTANCE, CREATE_COMPONENT, INHERITED_NAME } from "./core-types/symbols.mjs";
+import { assignProps, createBaseComponent, createComponent } from "./coreFactory.mjs";
+import { lastInteraction } from "./LastInteractionType.mjs";
+import { default as default2 } from "./register.mjs";
+import "./styled/index.mjs";
+import { sstyled } from "./styled/sstyled.mjs";
+export {
+  CHILDREN_COMPONENT,
+  CONTEXT_COMPONENT,
+  CORE_INSTANCE,
+  CREATE_COMPONENT,
+  Component,
+  INHERITED_NAME,
+  Intergalactic,
+  Root,
+  assignProps,
+  createBaseComponent,
+  createComponent,
+  lastInteraction,
+  default2 as register,
+  sstyled,
+  wrapIntergalacticComponent
+};

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Root","Component","Intergalactic","wrapIntergalacticComponent","CORE_INSTANCE","CREATE_COMPONENT","CONTEXT_COMPONENT","CHILDREN_COMPONENT","INHERITED_NAME","createComponent","createBaseComponent","assignProps","lastInteraction","register","sstyled"],"sources":["../src/index.ts"],"sourcesContent":["/** ============================== core ============================== */\nimport { Root, Component, Intergalactic, wrapIntergalacticComponent } from './core-types/Component';\nimport type {\n  PropGetterFn,\n  IRootComponentProps,\n  IRootNodeProps,\n} from './core-types/Component';\nimport {\n  CORE_INSTANCE,\n  CREATE_COMPONENT,\n  CONTEXT_COMPONENT,\n  CHILDREN_COMPONENT,\n  INHERITED_NAME,\n} from './core-types/symbols';\nimport type { UnknownProperties } from './core-types/UnknownProperties';\nimport { createComponent, createBaseComponent, assignProps } from './coreFactory';\nimport { lastInteraction } from './LastInteractionType';\nimport register from './register';\nimport type { IStyledProps } from './styled';\nimport { sstyled } from './styled';\n\nexport {\n  sstyled,\n  createComponent,\n  createBaseComponent,\n  Root,\n  Component,\n  type UnknownProperties,\n  Intergalactic,\n  type PropGetterFn,\n  type IRootComponentProps,\n  type IRootNodeProps,\n  CORE_INSTANCE,\n  CREATE_COMPONENT,\n  CONTEXT_COMPONENT,\n  CHILDREN_COMPONENT,\n  INHERITED_NAME,\n  type IStyledProps,\n  wrapIntergalacticComponent,\n  assignProps,\n  register,\n  lastInteraction,\n};\n"],"mappings":"AAAA;AACA,SAASA,IAAI,EAAEC,SAAS,EAAEC,aAAa,EAAEC,0BAA0B,QAAQ,4BAAwB;AAMnG,SACEC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,kBAAkB,EAClBC,cAAc,QACT,0BAAsB;AAE7B,SAASC,eAAe,EAAEC,mBAAmB,EAAEC,WAAW,QAAQ,mBAAe;AACjF,SAASC,eAAe,QAAQ,2BAAuB;AACvD,OAAOC,QAAQ,MAAM,gBAAY;AAEjC,SAASC,OAAO,QAAQ,cAAU;AAElC,SACEA,OAAO,EACPL,eAAe,EACfC,mBAAmB,EACnBV,IAAI,EACJC,SAAS,EAETC,aAAa,EAIbE,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,kBAAkB,EAClBC,cAAc,EAEdL,0BAA0B,EAC1BQ,WAAW,EACXE,QAAQ,EACRD,eAAe","ignoreList":[]}

package/lib/register.d.ts

@@ -0,0 +1,8 @@
+declare class Register {
+    data: any;
+    get<D>(name: string, defaultValue?: D): D;
+    set<D>(name: string, value: D): D;
+}
+export { Register };
+declare const _default: Register;
+export default _default;

package/lib/register.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.Register = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var Register = exports.Register = /*#__PURE__*/function () {
+  function Register() {
+    (0, _classCallCheck2["default"])(this, Register);
+    (0, _defineProperty2["default"])(this, "data", {});
+  }
+  return (0, _createClass2["default"])(Register, [{
+    key: "get",
+    value: function get(name, defaultValue) {
+      if (name in this.data) {
+        return this.data[name];
+      } else {
+        return this.set(name, defaultValue);
+      }
+    }
+  }, {
+    key: "set",
+    value: function set(name, value) {
+      this.data[name] = value;
+      return this.data[name];
+    }
+  }]);
+}();
+var _default = exports["default"] = new Register();
+//# sourceMappingURL=register.js.map