@tempots/dom 10.0.111 → 11.0.0

package/mountable/task.d.ts

@@ -1,7 +1,7 @@
-import { Child, Mountable } from '../types/domain';
+import { TNode, Renderable } from '../types/domain';
 
 export declare const Task: <T>(task: () => Promise<T>, options: {
-    pending?: Child;
-    then: (value: T) => Child;
-    error?: (error: unknown) => Child;
-} | ((value: T) => Child)) => Mountable;
+    pending?: TNode;
+    then: (value: T) => TNode;
+    error?: (error: unknown) => TNode;
+} | ((value: T) => TNode)) => Renderable;

package/mountable/text.d.ts

@@ -1,6 +1,6 @@
-import { Mountable } from '../types/domain';
+import { Renderable } from '../types/domain';
 import { Signal, Value } from '../std/signal';
 
-export declare const staticText: (text: string) => Mountable;
-export declare const signalText: (signal: Signal<string>) => Mountable;
-export declare function Text(value: Value<string>): Mountable;
+export declare const staticText: (text: string) => Renderable;
+export declare const signalText: (signal: Signal<string>) => Renderable;
+export declare function Text(value: Value<string>): Renderable;

package/mountable/when.d.ts

@@ -1,4 +1,4 @@
-import { Child, Signal } from '..';
+import { TNode, Signal } from '..';
 
-export declare const When: (condition: Signal<boolean>, then: Child, otherwise?: Child) => import('..').Mountable;
-export declare const Unless: (condition: Signal<boolean>, then: Child, otherwise?: Child) => import('..').Mountable;
+export declare const When: (condition: Signal<boolean>, then: TNode, otherwise?: TNode) => import('..').Renderable;
+export declare const Unless: (condition: Signal<boolean>, then: TNode, otherwise?: TNode) => import('..').Renderable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempots/dom",
-  "version": "10.0.111",
+  "version": "11.0.0",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -12,12 +12,28 @@
     }
   },
   "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/fponticelli/tempots.git"
-  },
+  "description": "Fully-typed frontend framework alternative to React and Angular",
+  "keywords": [
+    "tempo",
+    "tempots",
+    "ui",
+    "framework",
+    "typescript",
+    "dom",
+    "angular-alternative",
+    "react-alternative"
+  ],
+  "homepage": "https://github.com/fponticelli/tempots",
   "bugs": {
     "url": "https://github.com/fponticelli/tempots/issues"
   },
-  "homepage": "https://github.com/fponticelli/tempots#readme"
-}
+  "author": {
+    "name": "Franco Ponticelli",
+    "email": "franco.ponticelli@gmail.com",
+    "url": "https://github.com/fponticelli"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fponticelli/tempots.git"
+  }
+}

package/std/signal.d.ts

@@ -1,6 +1,10 @@
-declare const $isSignal: unique symbol;
-declare const $isProp: unique symbol;
-declare const $isComputed: unique symbol;
+declare const $isSignal = "$__signal__";
+declare const $isProp = "$__prop__";
+declare const $isComputed = "$__computed__";
+export type AnySignal<T = any> = Signal<T> | Prop<T> | Computed<T>;
+/**
+ * @category Signal Implementation
+ */
 export declare class Signal<T> {
     readonly equals: (a: T, b: T) => boolean;
     static ofPromise<T>(promise: Promise<T>, init: T, recover?: (error: unknown) => T, equals?: (a: T, b: T) => boolean): Signal<T>;
@@ -28,6 +32,7 @@ export declare class Signal<T> {
     readonly flatMap: <U>(fn: (value: T) => Signal<U>, equals?: (a: U, b: U) => boolean) => Computed<U>;
     readonly tap: (fn: (value: T) => void) => Computed<T>;
     readonly at: <K extends keyof T>(key: K) => Signal<T[K]>;
+    readonly $: { [K in keyof T]: Signal<T[K]>; };
     readonly filter: (fn: (value: T) => boolean, startValue?: T) => Computed<T>;
     readonly filterMap: <U>(fn: (value: T) => U | undefined | null, startValue: U, equals?: (a: U, b: U) => boolean) => Computed<U>;
     readonly mapAsync: <U>(fn: (value: T) => Promise<U>, alt: U, recover?: (error: unknown) => U, equals?: (a: U, b: U) => boolean) => Prop<U>;
@@ -37,6 +42,9 @@ export declare class Signal<T> {
     readonly count: () => Computed<number>;
     readonly setDerivative: <U>(computed: Computed<U>) => void;
 }
+/**
+ * @category Signal Implementation
+ */
 export declare class Computed<T> extends Signal<T> {
     private readonly _fn;
     static is<T = unknown>(value: unknown): value is Computed<T>;
@@ -49,19 +57,28 @@ export declare class Computed<T> extends Signal<T> {
     readonly get: () => T;
     get value(): T;
 }
+export type ReducerEffect<S, A> = (data: {
+    previousState: S;
+    state: S;
+    action: A;
+    dispatch: (action: A) => void;
+}) => void;
+/**
+ * @category Signal Implementation
+ */
 export declare class Prop<T> extends Signal<T> {
     static is<T = unknown>(value: unknown): value is Prop<T>;
     protected readonly [$isProp] = true;
     readonly set: (value: T) => void;
     readonly update: (fn: (value: T) => T) => void;
-    readonly reducer: <U>(fn: (acc: T, value: U) => T) => (action: U) => void;
+    readonly reducer: <A>(fn: (acc: T, value: A) => T, ...effects: ReducerEffect<T, A>[]) => (action: A) => void;
     readonly iso: <U>(to: (value: T) => U, from: (value: U) => T, equals?: (a: U, b: U) => boolean) => Prop<U>;
     readonly atProp: <K extends keyof T>(key: K) => Prop<T[K]>;
     get value(): T;
     set value(value: T);
 }
-export declare function computed<T>(fn: () => T, signals: Array<Signal<any>>, equals?: (a: T, b: T) => boolean): Computed<T>;
-export declare function effect(fn: () => void, signals: Array<Signal<any>>): () => void;
+export declare function computed<T>(fn: () => T, signals: Array<AnySignal>, equals?: (a: T, b: T) => boolean): Computed<T>;
+export declare function effect(fn: () => void, signals: Array<AnySignal>): () => void;
 export declare function prop<T>(value: T, equals?: (a: T, b: T) => boolean): Prop<T>;
 export declare function signal<T>(value: T, equals?: (a: T, b: T) => boolean): Signal<T>;
 export declare class MemoryStore {
@@ -97,7 +114,7 @@ export declare function propOfSessionStorage<T>(options: {
     equals?: (a: T, b: T) => boolean;
     onLoad?: (value: T) => T;
 }): Prop<T>;
-export declare function animate<T>(initialValue: T, fn: () => T, signals: Array<Signal<any>>, options?: {
+export declare function animate<T>(initialValue: T, fn: () => T, signals: Array<AnySignal>, options?: {
     interpolate?: (start: T, end: T, delta: number) => T;
     duration?: Value<number>;
     easing?: (t: number) => number;

package/types/css-styles.d.ts

@@ -1,3 +1,2 @@
-type ExcludeFromStyle = 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty' | 'parentRule' | 'length' | 'name' | number;
+export type ExcludeFromStyle = 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty' | 'parentRule' | 'length' | 'name' | number;
 export type CSSStyles = Omit<CSSStyleDeclaration, ExcludeFromStyle>;
-export {};

package/types/domain.d.ts

@@ -1,8 +1,8 @@
 import { DOMContext } from '../dom/dom-context';
 import { Value } from '../std/signal';
 
-export type Mountable = (ctx: DOMContext) => Clear;
-export type Child = Mountable | Value<string> | undefined | null | Mountable[];
+export type Renderable = (ctx: DOMContext) => Clear;
+export type TNode = Renderable | Value<string> | undefined | null | Renderable[];
 export type Clear = (removeTree: boolean) => void;
 export type ProviderMark<T> = symbol & {
     readonly __type: T;

package/types/html-attributes.d.ts

@@ -77,6 +77,7 @@ export type HTMLAttributes = {
     rel: string;
     required: string;
     reversed: string;
+    role: string;
     rows: number;
     rowspan: number;
     sandbox: string;
@@ -100,7 +101,7 @@ export type HTMLAttributes = {
     target: string;
     title: string;
     translate: string;
-    type: InputTypes;
+    type: string;
     usemap: string;
     value: string;
     valueAsNumber: number;