@simpreact/simpreact 0.0.0-alpha.dd6f145 → 0.0.1

package/hooks/index.d.ts

@@ -1,10 +1,23 @@
-import type { VoidFunction } from '../shared';
-type Cleanup = VoidFunction;
-type Effect = () => void | Cleanup;
-type DependencyList = readonly unknown[];
-export declare function useRef<T>(initialValue: T): {
-    current: T;
-};
-export declare function useRerender(): VoidFunction;
-export declare function useEffect(effect: Effect, deps?: DependencyList): void;
-export {};
+import type { RefObject, SimpContext } from '../core';
+
+export type Cleanup = () => void;
+export type Effect = () => void | Cleanup;
+export type DependencyList = readonly unknown[];
+
+declare function useRef<T>(initialValue: T): RefObject<T>;
+declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+declare function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
+
+declare function useRerender(): () => void;
+
+declare function useEffect(effect: Effect, deps?: DependencyList): void;
+
+declare function useMounted(effect: Effect): void;
+
+declare function useUnmounted(cleanup: Cleanup): void;
+
+declare function useContext<T>(context: SimpContext<T>): T;
+
+declare function useCatch(cb: (error: any) => void): void;
+
+declare function areDepsEqual(nextDeps: DependencyList | undefined, prevDeps: DependencyList | undefined): boolean;

package/hooks/index.js

@@ -1,61 +1,136 @@
-import { GLOBAL, rerender } from '../core/internal';
+import { lifecycleEventBus, rerender, syncRerenderLocker } from '../core/internal.js';
+import { noop } from '../shared';
 let currentIndex = 0;
-let currentElement = null;
-GLOBAL.eventBus.subscribe(event => {
+// In runtime this is a nullable variable.
+let currentElement;
+lifecycleEventBus.subscribe(event => {
     if (event.type === 'beforeRender') {
         currentElement = event.element;
-        currentElement.store || (currentElement.store = { hookStates: [], mountEffects: [] });
-        currentElement.store.mountEffects = [];
+        if (currentElement.store?.catchHandlers) {
+            currentElement.store.catchHandlers = undefined;
+        }
     }
-    if (event.type === 'afterRender') {
+    if (event.type === 'afterRender' || event.type === 'errored') {
         currentElement = null;
         currentIndex = 0;
     }
     if (event.type === 'mounted') {
-        for (const state of event.element.store.mountEffects) {
-            if (typeof state.cleanup === 'function') {
-                state.cleanup();
+        const element = event.element;
+        if (element.store?.effectsHookStates) {
+            syncRerenderLocker.lock();
+            const effects = element.store.effectsHookStates;
+            element.store.effectsHookStates = undefined;
+            for (const state of effects) {
+                state.cleanup = state.effect() || undefined;
+            }
+            syncRerenderLocker.flush();
+        }
+    }
+    if (event.type === 'updated') {
+        const element = event.element;
+        if (element.store?.effectsHookStates) {
+            syncRerenderLocker.lock();
+            const effects = element.store.effectsHookStates;
+            element.store.effectsHookStates = undefined;
+            for (const state of effects) {
+                if (typeof state.cleanup === 'function') {
+                    state.cleanup();
+                }
+                state.cleanup = state.effect() || undefined;
             }
-            state.cleanup = state.effect() || undefined;
+            syncRerenderLocker.flush();
         }
     }
     if (event.type === 'unmounted') {
-        for (const state of event.element.store.hookStates) {
-            if (state && 'cleanup' in state && typeof state.cleanup === 'function') {
-                state.cleanup();
+        const element = event.element;
+        if (element.store?.hookStates) {
+            for (const state of element.store.hookStates) {
+                if (state && 'cleanup' in state && typeof state.cleanup === 'function') {
+                    state.cleanup();
+                }
+            }
+        }
+    }
+    if (event.type === 'errored') {
+        const element = findElementWithCatchHandlers(event.element);
+        if (!element) {
+            throw new Error('Error occurred during rendering a component', { cause: event.error });
+        }
+        if (element.store.catchHandlers) {
+            syncRerenderLocker.lock();
+            for (const state of element.store.catchHandlers) {
+                state(event.error);
             }
+            syncRerenderLocker.flush();
         }
     }
 });
+function findElementWithCatchHandlers(element) {
+    let temp = element;
+    while (temp != null) {
+        if (temp.store?.catchHandlers) {
+            return temp;
+        }
+        temp = temp.parent;
+    }
+    return null;
+}
 export function useRef(initialValue) {
-    var _a, _b;
-    return ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = { current: initialValue }));
+    const hookStates = getOrCreateHookStates(currentElement);
+    if (!hookStates[currentIndex]) {
+        hookStates[currentIndex] = { current: initialValue };
+    }
+    return hookStates[currentIndex++];
 }
 export function useRerender() {
-    var _a, _b;
-    const state = ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = {
-        element: null,
-        fn() {
-            rerender(state.element);
-        },
-    }));
-    state.element = currentElement;
-    return state.fn;
+    const hookStates = getOrCreateHookStates(currentElement);
+    if (!hookStates[currentIndex]) {
+        const elementStore = currentElement.store;
+        hookStates[currentIndex] = () => rerender(elementStore.latestElement);
+    }
+    return hookStates[currentIndex++];
 }
 export function useEffect(effect, deps) {
-    var _a, _b;
-    const state = ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = {
-        effect,
-        deps: undefined,
-        cleanup: undefined,
-    }));
+    const hookStates = getOrCreateHookStates(currentElement);
+    let state = hookStates[currentIndex];
+    if (!state) {
+        state = hookStates[currentIndex] = { effect };
+    }
     if (!areDepsEqual(deps, state.deps)) {
         state.effect = effect;
         state.deps = deps;
-        currentElement.store.mountEffects.push(state);
+        getOrCreateEffectHookStates(currentElement).push(state);
     }
+    currentIndex++;
 }
-function areDepsEqual(nextDeps, prevDeps) {
+export function useMounted(effect) {
+    const hookStates = getOrCreateHookStates(currentElement);
+    if (!hookStates[currentIndex]) {
+        hookStates[currentIndex] = { effect };
+        getOrCreateEffectHookStates(currentElement).push(hookStates[currentIndex]);
+    }
+    currentIndex++;
+}
+export function useUnmounted(cleanup) {
+    const hookStates = getOrCreateHookStates(currentElement);
+    if (!hookStates[currentIndex]) {
+        hookStates[currentIndex] = { cleanup, effect: noop };
+    }
+    currentIndex++;
+}
+export function useContext(context) {
+    return currentElement.contextMap?.get(context) ?? context.defaultValue;
+}
+export function useCatch(cb) {
+    if (!currentElement.store) {
+        currentElement.store = {};
+    }
+    if (!currentElement.store.catchHandlers) {
+        currentElement.store.catchHandlers = [];
+    }
+    currentElement.store.catchHandlers.push(cb);
+}
+export function areDepsEqual(nextDeps, prevDeps) {
     if (nextDeps == null || prevDeps == null || nextDeps.length !== prevDeps.length) {
         return false;
     }
@@ -66,3 +141,22 @@ function areDepsEqual(nextDeps, prevDeps) {
     }
     return true;
 }
+function getOrCreateHookStates(element) {
+    if (!element.store) {
+        element.store = {};
+    }
+    if (!element.store.hookStates) {
+        element.store.hookStates = [];
+    }
+    return element.store.hookStates;
+}
+function getOrCreateEffectHookStates(element) {
+    if (!element.store) {
+        element.store = {};
+    }
+    if (!element.store.effectsHookStates) {
+        element.store.effectsHookStates = [];
+    }
+    return element.store.effectsHookStates;
+}
+export default { useRef, useRerender, useEffect, useMounted, useUnmounted, useContext, useCatch, areDepsEqual };

package/jsx-runtime/index.d.ts

@@ -1,7 +1,250 @@
-import type { FunctionComponent, SimpElement } from '../core';
-import { Fragment } from '../core';
+import type { FC, Fragment as FragmentType, Key, SimpElement } from '../core';
 import type { Maybe } from '../shared';
-import type { Key, Props } from '../core/createElement';
-export declare function jsx(type: string | FunctionComponent<any>, props?: Maybe<Props>, key?: Maybe<Key>): SimpElement;
+import type {
+  AnchorHTMLAttributes,
+  AreaHTMLAttributes,
+  AudioHTMLAttributes,
+  BaseHTMLAttributes,
+  BlockquoteHTMLAttributes,
+  ButtonHTMLAttributes,
+  CanvasHTMLAttributes,
+  ColgroupHTMLAttributes,
+  ColHTMLAttributes,
+  DataHTMLAttributes,
+  DelHTMLAttributes,
+  DetailedHTMLProps,
+  DetailsHTMLAttributes,
+  DialogHTMLAttributes,
+  EmbedHTMLAttributes,
+  FieldsetHTMLAttributes,
+  FormHTMLAttributes,
+  HTMLAttributes,
+  HtmlHTMLAttributes,
+  IframeHTMLAttributes,
+  ImgHTMLAttributes,
+  InputHTMLAttributes,
+  InsHTMLAttributes,
+  KeygenHTMLAttributes,
+  LabelHTMLAttributes,
+  LiHTMLAttributes,
+  LinkHTMLAttributes,
+  MapHTMLAttributes,
+  MenuHTMLAttributes,
+  MetaHTMLAttributes,
+  MeterHTMLAttributes,
+  ObjectHTMLAttributes,
+  OlHTMLAttributes,
+  OptgroupHTMLAttributes,
+  OptionHTMLAttributes,
+  OutputHTMLAttributes,
+  ParamHTMLAttributes,
+  ProgressHTMLAttributes,
+  QuoteHTMLAttributes,
+  ScriptHTMLAttributes,
+  SelectHTMLAttributes,
+  SlotHTMLAttributes,
+  SourceHTMLAttributes,
+  StyleHTMLAttributes,
+  SVGProps,
+  TableHTMLAttributes,
+  TdHTMLAttributes,
+  TextareaHTMLAttributes,
+  ThHTMLAttributes,
+  TimeHTMLAttributes,
+  TrackHTMLAttributes,
+  VideoHTMLAttributes,
+  WebViewHTMLAttributes,
+} from '../dom';
+
+declare function jsx<P = {}>(type: string | FC<P>, props?: P, key?: Maybe<Key>): SimpElement<P>;
+
+type Fragment = FragmentType;
+
 export { jsx as jsxs, jsx as jsxDEV };
 export { Fragment };
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      // HTML
+      a: DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
+      abbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      address: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      area: DetailedHTMLProps<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
+      article: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      aside: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      audio: DetailedHTMLProps<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
+      b: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      base: DetailedHTMLProps<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
+      bdi: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      bdo: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      big: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      blockquote: DetailedHTMLProps<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
+      body: DetailedHTMLProps<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
+      br: DetailedHTMLProps<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
+      button: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+      canvas: DetailedHTMLProps<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
+      caption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      center: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      cite: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      code: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      col: DetailedHTMLProps<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
+      colgroup: DetailedHTMLProps<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
+      data: DetailedHTMLProps<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
+      datalist: DetailedHTMLProps<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
+      dd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      del: DetailedHTMLProps<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
+      details: DetailedHTMLProps<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
+      dfn: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      dialog: DetailedHTMLProps<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
+      div: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+      dl: DetailedHTMLProps<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
+      dt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      em: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      embed: DetailedHTMLProps<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
+      fieldset: DetailedHTMLProps<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
+      figcaption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      figure: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      footer: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      form: DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
+      h1: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      h2: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      h3: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      h4: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      h5: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      h6: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+      head: DetailedHTMLProps<HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>;
+      header: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      hgroup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      hr: DetailedHTMLProps<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
+      html: DetailedHTMLProps<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
+      i: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      iframe: DetailedHTMLProps<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
+      img: DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
+      input: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+      ins: DetailedHTMLProps<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
+      kbd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      keygen: DetailedHTMLProps<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
+      label: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+      legend: DetailedHTMLProps<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
+      li: DetailedHTMLProps<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
+      link: DetailedHTMLProps<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
+      main: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      map: DetailedHTMLProps<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
+      mark: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      menu: DetailedHTMLProps<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
+      menuitem: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      meta: DetailedHTMLProps<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
+      meter: DetailedHTMLProps<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
+      nav: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      noindex: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      noscript: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      object: DetailedHTMLProps<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
+      ol: DetailedHTMLProps<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
+      optgroup: DetailedHTMLProps<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
+      option: DetailedHTMLProps<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
+      output: DetailedHTMLProps<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
+      p: DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+      param: DetailedHTMLProps<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
+      picture: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      pre: DetailedHTMLProps<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
+      progress: DetailedHTMLProps<ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>;
+      q: DetailedHTMLProps<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
+      rp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      rt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      ruby: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      s: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      samp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      search: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      slot: DetailedHTMLProps<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
+      script: DetailedHTMLProps<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
+      section: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      select: DetailedHTMLProps<SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
+      small: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      source: DetailedHTMLProps<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
+      span: DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+      strong: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      style: DetailedHTMLProps<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
+      sub: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      summary: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      sup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      table: DetailedHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
+      template: DetailedHTMLProps<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
+      tbody: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+      td: DetailedHTMLProps<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
+      textarea: DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
+      tfoot: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+      th: DetailedHTMLProps<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
+      thead: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+      time: DetailedHTMLProps<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
+      title: DetailedHTMLProps<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
+      tr: DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
+      track: DetailedHTMLProps<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
+      u: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      ul: DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
+      var: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      video: DetailedHTMLProps<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
+      wbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+      webview: DetailedHTMLProps<WebViewHTMLAttributes<HTMLElement>, HTMLElement>;
+
+      // SVG
+      svg: SVGProps<SVGSVGElement>;
+
+      circle: SVGProps<SVGCircleElement>;
+      clipPath: SVGProps<SVGClipPathElement>;
+      defs: SVGProps<SVGDefsElement>;
+      desc: SVGProps<SVGDescElement>;
+      ellipse: SVGProps<SVGEllipseElement>;
+      feBlend: SVGProps<SVGFEBlendElement>;
+      feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
+      feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
+      feComposite: SVGProps<SVGFECompositeElement>;
+      feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
+      feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
+      feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
+      feDistantLight: SVGProps<SVGFEDistantLightElement>;
+      feDropShadow: SVGProps<SVGFEDropShadowElement>;
+      feFlood: SVGProps<SVGFEFloodElement>;
+      feFuncA: SVGProps<SVGFEFuncAElement>;
+      feFuncB: SVGProps<SVGFEFuncBElement>;
+      feFuncG: SVGProps<SVGFEFuncGElement>;
+      feFuncR: SVGProps<SVGFEFuncRElement>;
+      feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
+      feImage: SVGProps<SVGFEImageElement>;
+      feMerge: SVGProps<SVGFEMergeElement>;
+      feMergeNode: SVGProps<SVGFEMergeNodeElement>;
+      feMorphology: SVGProps<SVGFEMorphologyElement>;
+      feOffset: SVGProps<SVGFEOffsetElement>;
+      fePointLight: SVGProps<SVGFEPointLightElement>;
+      feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
+      feSpotLight: SVGProps<SVGFESpotLightElement>;
+      feTile: SVGProps<SVGFETileElement>;
+      feTurbulence: SVGProps<SVGFETurbulenceElement>;
+      filter: SVGProps<SVGFilterElement>;
+      foreignObject: SVGProps<SVGForeignObjectElement>;
+      g: SVGProps<SVGGElement>;
+      image: SVGProps<SVGImageElement>;
+      line: SVGProps<SVGLineElement>;
+      linearGradient: SVGProps<SVGLinearGradientElement>;
+      marker: SVGProps<SVGMarkerElement>;
+      mask: SVGProps<SVGMaskElement>;
+      metadata: SVGProps<SVGMetadataElement>;
+      mpath: SVGProps<SVGElement>;
+      path: SVGProps<SVGPathElement>;
+      pattern: SVGProps<SVGPatternElement>;
+      polygon: SVGProps<SVGPolygonElement>;
+      polyline: SVGProps<SVGPolylineElement>;
+      radialGradient: SVGProps<SVGRadialGradientElement>;
+      rect: SVGProps<SVGRectElement>;
+      set: SVGProps<SVGSetElement>;
+      stop: SVGProps<SVGStopElement>;
+      switch: SVGProps<SVGSwitchElement>;
+      symbol: SVGProps<SVGSymbolElement>;
+      text: SVGProps<SVGTextElement>;
+      textPath: SVGProps<SVGTextPathElement>;
+      tspan: SVGProps<SVGTSpanElement>;
+      use: SVGProps<SVGUseElement>;
+      view: SVGProps<SVGViewElement>;
+    }
+  }
+}

package/jsx-runtime/index.js

@@ -1,14 +1,11 @@
-import { createElement, Fragment } from '../core';
+import { createElement, Fragment } from '../core/internal.js';
 export function jsx(type, props, key) {
-    let _key;
-    if (key != null) {
-        _key = key;
-    }
+    let _key = key;
     if (props && props.key != null) {
         _key = props.key;
     }
     if (_key != null) {
-        (props || (props = {})).key = _key;
+        (props ||= {}).key = _key;
     }
     return createElement(type, props);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simpreact/simpreact",
-  "version": "0.0.0-alpha.dd6f145",
+  "version": "0.0.1",
   "description": "",
   "homepage": "https://github.com/dPaskhin/simpreact#readme",
   "main": "./core/index.js",
@@ -8,28 +8,32 @@
   "types": "./core/index.d.ts",
   "exports": {
     ".": {
-      "types": "./core/index.d.ts",
-      "import": "./core/index.js"
+      "import": "./core/index.js",
+      "types": "./core/index.d.ts"
+    },
+    "./internal": {
+      "import": "./core/internal.js",
+      "types": "./core/internal.d.ts"
     },
     "./jsx-runtime": {
-      "types": "./jsx-runtime/index.d.ts",
-      "import": "./jsx-runtime/index.js"
+      "import": "./jsx-runtime/index.js",
+      "types": "./jsx-runtime/index.d.ts"
     },
     "./jsx-dev-runtime": {
-      "types": "./jsx-runtime/index.d.ts",
-      "import": "./jsx-runtime/index.js"
+      "import": "./jsx-runtime/index.js",
+      "types": "./jsx-runtime/index.d.ts"
     },
     "./hooks": {
-      "types": "./hooks/index.d.ts",
-      "import": "./hooks/index.js"
+      "import": "./hooks/index.js",
+      "types": "./hooks/index.d.ts"
     },
     "./dom": {
-      "types": "./dom/index.d.ts",
-      "import": "./dom/index.js"
+      "import": "./dom/index.js",
+      "types": "./dom/index.d.ts"
     },
     "./shared": {
-      "types": "./shared/index.d.ts",
-      "import": "./shared/index.js"
+      "import": "./shared/index.js",
+      "types": "./shared/index.d.ts"
     }
   },
   "bugs": {
@@ -39,7 +43,10 @@
     "type": "git",
     "url": "git+https://github.com/dPaskhin/simpreact.git"
   },
-  "type": "module",
+  "sideEffects": false,
   "license": "MIT",
-  "author": "Dmitrii Paskhin <d.pasxin@gmail.com>"
+  "author": "Dmitrii Paskhin <d.pasxin@gmail.com>",
+  "dependencies": {
+    "csstype": "^3.1.3"
+  }
 }

package/shared/EventBus.js

@@ -1,7 +1,5 @@
 export class EventBus {
-    constructor() {
-        this._subscribers = [];
-    }
+    _subscribers = [];
     /**
      * Synchronously invokes subscribers and passes the event.
      *

package/shared/index.d.ts

@@ -1,4 +1,19 @@
-export * from './EventBus';
-export * from './lang';
-export * from './types';
-export * from './utils';
+export type Nullable<T> = T | null;
+
+export type Maybe<T> = Nullable<T> | undefined;
+
+export type Many<T> = T[] | T;
+
+export type Dict<T = any> = Record<string, T>;
+
+export type SimpText = string | number | bigint;
+
+type Subscriber<Event> = (event: Event) => boolean | void;
+
+declare class EventBus<Event = void> {
+  public publish(event: Event): void;
+
+  public subscribe(subscriber: Subscriber<Event>): () => void;
+}
+
+declare function isSimpText(value: unknown): value is SimpText;

package/shared/index.js

@@ -1,4 +1,5 @@
-export * from './EventBus';
-export * from './lang';
-export * from './types';
-export * from './utils';
+import { EventBus } from './EventBus';
+import { emptyArray, emptyMap, emptyObject } from './lang';
+import { isSimpText, noop } from './utils';
+export { emptyObject, emptyMap, emptyArray, isSimpText, EventBus, noop };
+export default { isSimpText, EMPTY_MAP: emptyMap, EMPTY_ARRAY: emptyArray, EMPTY_OBJECT: emptyObject, EventBus, noop };

package/shared/lang.d.ts

@@ -1,4 +1,3 @@
-export declare const EMPTY_OBJECT: Readonly<{}>;
-export declare const EMPTY_ARRAY: readonly never[];
-export declare const EMPTY_MAP: Map<any, any>;
-export declare const isArray: (arg: any) => arg is any[];
+export declare const emptyObject: Readonly<{}>;
+export declare const emptyArray: readonly never[];
+export declare const emptyMap: Map<any, any>;

package/shared/lang.js

@@ -1,4 +1,3 @@
-export const EMPTY_OBJECT = Object.freeze({});
-export const EMPTY_ARRAY = Object.freeze([]);
-export const EMPTY_MAP = new Map();
-export const isArray = Array.isArray;
+export const emptyObject = Object.freeze({});
+export const emptyArray = Object.freeze([]);
+export const emptyMap = new Map();

package/shared/utils.d.ts

@@ -1,3 +1,3 @@
-import type { Primitive } from './types';
-export declare const IS_DEVELOPMENT: boolean;
-export declare function isPrimitive(value: unknown): value is Primitive;
+import type { SimpText } from './public';
+export declare function isSimpText(value: unknown): value is SimpText;
+export declare function noop(): void;

package/shared/utils.js

@@ -1,8 +1,4 @@
-export const IS_DEVELOPMENT = process.env.NODE_ENV !== 'production';
-export function isPrimitive(value) {
-    return (value == null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'bigint' ||
-        typeof value === 'boolean');
+export function isSimpText(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint';
 }
+export function noop() { }