vasille-jsx 3.1.0 → 3.1.2

package/lib/internal.js

@@ -1,5 +1,5 @@
 import { proxyArrayModel, Expression, Pointer, Reference } from "vasille";
-import { reactiveObject, reactiveObjectProxy, stateReactiveObject } from "./objects.js";
+import { reactiveObject, reactiveObjectProxy, storeReactiveObject } from "./objects.js";
 import { ContextArray, ContextMap, ContextSet } from "./models.js";
 export const internal = {
     /** create an expression (without context), use it for OwningPointer */
@@ -33,7 +33,7 @@ export const internal = {
         return node.register(proxyArrayModel(new ContextArray(data)), name);
     },
     /** translate `{...} to $.sro({...})` */
-    sro: stateReactiveObject,
+    sro: storeReactiveObject,
     /** translate `new Set(#)` to `$.ssm(#)` */
     ssm(data) {
         return new ContextSet(data);

package/lib/library.js

@@ -1,4 +1,5 @@
 import { IValue } from "vasille";
+import { storeReactiveObject } from "./objects.js";
 export function awaited(node, target, errName, dataName) {
     const value = node.ref(undefined, dataName);
     const err = node.ref(undefined, errName);
@@ -34,6 +35,11 @@ export function awaited(node, target, errName, dataName) {
     run();
     return [err, value, run];
 }
+export function store(fn) {
+    return (input) => {
+        return input ? fn(storeReactiveObject(input)) : fn();
+    };
+}
 export function ensureIValue(node, value) {
     return value instanceof IValue ? value : node.ref(value);
 }

package/lib/objects.js

@@ -79,7 +79,7 @@ export function reactiveObjectProxy(o) {
         },
     });
 }
-export function stateReactiveObject(o) {
+export function storeReactiveObject(o) {
     for (const key of Object.keys(o)) {
         if (!(o[key] instanceof IValue)) {
             o[key] = new Reference(proxy(o[key]));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vasille-jsx",
-  "version": "3.1.0",
-  "description": "The first Developer eXperience orientated front-end framework (JSX components)",
+  "version": "3.1.2",
+  "description": "The first Developer eXperience Orientated front-end framework (JSX components)",
   "main": "lib/index.js",
   "exports": {
     "types": "./types/index.d.ts",

package/types/internal.d.ts

@@ -1,5 +1,5 @@
 import { IValue, Reactive, KindOfIValue, Expression } from "vasille";
-import { reactiveObject, stateReactiveObject } from "./objects.js";
+import { reactiveObject, storeReactiveObject } from "./objects.js";
 import { ContextMap, ContextSet } from "./models.js";
 export declare const internal: {
     /** create an expression (without context), use it for OwningPointer */
@@ -21,7 +21,7 @@ export declare const internal: {
     /** translate `[...]` to `$.am(this, [...])` */
     am(node: Reactive, data?: unknown[], name?: string): import("vasille").ArrayModel<unknown>;
     /** translate `{...} to $.sro({...})` */
-    sro: typeof stateReactiveObject;
+    sro: typeof storeReactiveObject;
     /** translate `new Set(#)` to `$.ssm(#)` */
     ssm(data?: unknown[]): ContextSet<unknown>;
     /** translate `new Map(#)` to `$.smm(#)` */

package/types/library.d.ts

@@ -1,3 +1,4 @@
 import { IValue, Reactive } from "vasille";
 export declare function awaited<T>(node: Reactive, target: Promise<T> | (() => Promise<T>), errName?: string, dataName?: string): [IValue<unknown>, IValue<unknown>, () => void];
+export declare function store(fn: (input?: object) => object): (input?: object) => object;
 export declare function ensureIValue<T>(node: Reactive, value: T | IValue<T>): IValue<T>;

package/types/objects.d.ts

@@ -12,6 +12,6 @@ export declare function reactiveObjectProxy<T extends {
 }>(o: T): {
     [K in keyof T]: T[K] extends IValue<infer R> ? R : never;
 };
-export declare function stateReactiveObject<T extends object>(o: T): {
+export declare function storeReactiveObject<T extends object>(o: T): {
     [K in keyof T]: T[K] extends IValue<unknown> ? T[K] : IValue<T[K]>;
 };