@tempots/dom 8.0.1 → 9.0.1

package/components/If.d.ts

@@ -1,14 +1,14 @@
-import { type JSX } from '../jsx';
+import { type JSX } from '../jsx-runtime';
 import { type Signal } from '../prop';
 export interface IfProps {
     is: Signal<boolean>;
-    then?: JSX.DOMNode;
-    otherwise?: JSX.DOMNode;
+    then?: () => JSX.DOMNode;
+    otherwise?: () => JSX.DOMNode;
 }
 export declare function If({ is, then, otherwise }: IfProps): JSX.DOMNode;
 export interface WhenProps {
     is: Signal<boolean>;
-    children?: JSX.DOMNode;
+    children?: () => JSX.DOMNode;
 }
 export declare function When({ is, children }: WhenProps): JSX.DOMNode;
 export declare function Unless({ is, children }: WhenProps): JSX.DOMNode;

package/components/If.js

@@ -1,19 +1,19 @@
 import { OneOfImpl } from './OneOf';
 export function If({ is, then, otherwise }) {
-    return new OneOfImpl(is.map(v => v ? { 1: true } : { 2: false }), {
-        1: () => then,
-        2: () => otherwise
+    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
+        then: then || (() => null),
+        otherwise: otherwise || (() => null)
     });
 }
 export function When({ is, children }) {
-    return new OneOfImpl(is.map(v => v ? { 1: true } : { 2: false }), {
-        1: () => children,
-        2: () => null
+    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
+        then: children,
+        otherwise: (() => null)
     });
 }
 export function Unless({ is, children }) {
-    return new OneOfImpl(is.map(v => v ? { 1: true } : { 2: false }), {
-        1: () => null,
-        2: () => children
+    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
+        then: (() => null),
+        otherwise: children
     });
 }

package/components/NotEmpty.d.ts

@@ -3,7 +3,7 @@ import { type Signal } from '../prop';
 import { type JSX } from '../jsx-runtime';
 export interface NotEmptyProps<T> {
     on: Signal<T>;
-    whenEmpty?: JSX.DOMNode;
-    display: JSX.DOMNode;
+    whenEmpty?: () => JSX.DOMNode;
+    display: () => JSX.DOMNode;
 }
 export declare function NotEmpty<T extends unknown[] | Record<any, unknown>>({ on, display, whenEmpty }: NotEmptyProps<T>): JSX.DOMNode;

package/components/Repeat.js

@@ -87,6 +87,8 @@ export class RepeatImpl {
                 if (separatorClears.length > 0) {
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     separatorClears.pop()(true);
+                }
+                if (separatorProps.length > 0) {
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     separatorProps.pop().clean();
                 }

package/components/Show.d.ts

@@ -5,11 +5,11 @@ import { OneOfImpl } from './OneOf';
 export type Condition<T> = Signal<T | null | undefined> | Signal<T | undefined> | Signal<T | null> | Signal<T>;
 export interface ShowProps<T> {
     when: Condition<T>;
-    otherwise?: JSX.DOMNode;
+    otherwise?: () => JSX.DOMNode;
     children?: (value: Signal<NonNullable<T>>) => JSX.DOMNode;
 }
 export declare function Show<T>({ when, children, otherwise }: ShowProps<T>): OneOfImpl<{
-    T: NonNullable<T>;
+    then: NonNullable<T>;
 } | {
-    F: false;
+    otherwise: false;
 }>;

package/components/Show.js

@@ -1,8 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx } from "../jsx-runtime";
 import { OneOfImpl } from './OneOf';
 export function Show({ when, children, otherwise }) {
-    return new OneOfImpl(when.map(v => (v != null ? { T: v } : { F: false })), {
-        T: (v) => ((children && children(v)) || _jsx(_Fragment, {})),
-        F: (_) => (otherwise || _jsx(_Fragment, {}))
+    return new OneOfImpl(when.map(v => (v != null ? { then: v } : { otherwise: false })), {
+        then: (v) => ((children && children(v)) || _jsx(_Fragment, {})),
+        otherwise: otherwise || (() => _jsx(_Fragment, {}))
     });
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tempots/dom",
   "main": "index.js",
   "types": "index.d.ts",
-  "version": "8.0.1",
+  "version": "9.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fponticelli/tempots-dom.git"

package/prop.d.ts

@@ -33,6 +33,11 @@ export declare class Signal<T> {
     readonly clean: () => void;
     readonly count: () => Signal<number>;
     readonly animate: (duration: number, interpolate: (start: T, end: T, delta: number) => T, initialValue?: T | null, easing?: (t: number) => number) => Signal<T>;
+    readonly equals: (other: Signal<T>, equality?: ((a: T, b: T) => boolean) | undefined) => Signal<boolean>;
+    readonly isNull: () => Signal<boolean>;
+    readonly isNotNull: () => Signal<boolean>;
+    readonly isEmpty: () => Signal<boolean>;
+    readonly isNotEmpty: () => Signal<boolean>;
 }
 export declare class Prop<T> extends Signal<T> {
     static isProp<T = unknown>(x: unknown): x is Prop<T>;

package/prop.js

@@ -194,6 +194,17 @@ export class Signal {
         });
         return prop;
     };
+    equals = (other, equality) => {
+        return this.combine(other, (a, b) => {
+            if (equality != null)
+                return equality(a, b);
+            return a === b;
+        });
+    };
+    isNull = () => this.map(value => value == null);
+    isNotNull = () => this.map(value => value != null);
+    isEmpty = () => this.map(value => value == null || (Reflect.has(value, 'length') && Reflect.get(value, 'length') === 0));
+    isNotEmpty = () => this.map(value => value != null && (!Reflect.has(value, 'length') || Reflect.get(value, 'length') !== 0));
 }
 export class Prop extends Signal {
     static isProp(x) {