vasille-web 4.1.3 → 4.1.5

package/fake-types/index.d.ts

@@ -98,18 +98,9 @@ export declare function ElseIf(props: { $condition: unknown; slot?: unknown }):
 export declare function Else(props: { slot?: unknown }): void;
 
 /** Renders content several times using a model (array, map or set) */
-export declare function For<T>(props: {
-    of: readonly DeepReadonly<T>[];
-    slot?: (value: DeepReadonly<T>) => void;
-}): void;
-export declare function For<T>(props: {
-    of: ReadonlySet<DeepReadonly<T>>;
-    slot?: (value: DeepReadonly<T>) => void;
-}): void;
-export declare function For<K, T>(props: {
-    of: ReadonlyMap<DeepReadonly<K>, DeepReadonly<T>>;
-    slot?: (value: DeepReadonly<T>, index: DeepReadonly<K>) => void;
-}): void;
+export declare function For<T>(props: { of: readonly T[]; slot?: (value: T) => void }): void;
+export declare function For<T>(props: { of: ReadonlySet<T>; slot?: (value: T) => void }): void;
+export declare function For<K, T>(props: { of: ReadonlyMap<K, T>; slot?: (value: T, index: K) => void }): void;
 
 /** Refresh the content each time then the reactive model is updated */
 export declare function Watch<T>(props: { $model: T; slot?: (value: T) => void }): void;
@@ -120,35 +111,14 @@ export declare function Debug(props: { $model: unknown }): void;
 /** Render content after a while */
 export declare function Delay(props: { time?: number; slot?: unknown }): void;
 
-export type DeepReadonly<T> =
-    T extends Map<infer K, infer V>
-        ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
-        : T extends ReadonlyMap<infer K, infer V>
-          ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
-          : T extends WeakMap<infer K, infer V>
-            ? WeakMap<DeepReadonly<K>, DeepReadonly<V>>
-            : T extends Set<infer U>
-              ? ReadonlySet<DeepReadonly<U>>
-              : T extends ReadonlySet<infer U>
-                ? ReadonlySet<DeepReadonly<U>>
-                : T extends WeakSet<infer U>
-                  ? WeakSet<DeepReadonly<U>>
-                  : T extends Promise<infer U>
-                    ? Promise<DeepReadonly<U>>
-                    : T extends (...args: unknown[]) => unknown
-                      ? T
-                      : T extends {}
-                        ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
-                        : T;
-
 /** Stores a singleton state to memory */
-export declare function store<Return extends object>(fn: () => Return): DeepReadonly<Return>;
+export declare function store<Return extends object>(fn: () => Return): Return;
 
 /** Creates a model (state) constructor */
-export declare function model<Return extends object>(fn: () => Return): () => DeepReadonly<Return>;
+export declare function model<Return extends object>(fn: () => Return): () => Return;
 export declare function model<Input extends object, Return extends object>(
     fn: (input: Input) => Return,
-): (input: Input) => DeepReadonly<Return>;
+): (input: Input) => Return;
 
 export { QueryParams, ScreenProps, RouteParameters } from "vasille-router";
 export { Router, NavigationMode } from "vasille-router/web-router";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vasille-web",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "description": "The same framework which is designed to build bulletproof frontends.",
   "main": "index.js",
   "types": "./index.d.ts",

package/types/jsx-runtime.d.ts

@@ -14,7 +14,7 @@ type HtmlInput<K extends keyof HTMLElementTagNameMap & keyof HtmlTagMap> = {
     slot?: unknown;
 } & Partial<HtmlTagMap[K]["attrs"]> & prefixedObject<EventHandlers<HtmlTagMap[K]["events"]>, "on"> & Partial<prefixedObject<HtmlTagMap[K]["props"], "bind:">>;
 export declare namespace JSX {
-    type ElementType = keyof IntrinsicElements | ((props?: object) => void);
+    type ElementType = keyof IntrinsicElements | ((props: any) => void);
     type Element = never;
     type ElementClass = never;
     interface ElementChildrenAttribute {