@inlang/sdk 0.28.2 → 0.28.3

package/dist/reactivity/solid.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=solid.test.d.ts.map

package/dist/reactivity/solid.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.test.d.ts","sourceRoot":"","sources":["../../src/reactivity/solid.test.ts"],"names":[],"mappings":""}

package/dist/reactivity/solid.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { createSignal, createEffect, createMemo } from "./solid.js";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+describe("solid", () => {
+    it("sets and gets", () => {
+        const [get, set] = createSignal(0);
+        expect(get()).toBe(0);
+        set(1);
+        expect(get()).toBe(1);
+    });
+    it("runs an effect whenn the signal value change", () => {
+        const [get, set] = createSignal(0);
+        let count = 0;
+        createEffect(() => {
+            count++;
+            get();
+        });
+        expect(count).toBe(1);
+        set(1);
+        expect(count).toBe(2);
+        set(1);
+        expect(count).toBe(2);
+        set(0);
+        expect(count).toBe(3);
+    });
+    it("runs an effect on a derived signal, when the underlying signal changes", () => {
+        const [get, set] = createSignal(0);
+        const derived = () => get() * 2;
+        let count = 0;
+        createEffect(() => {
+            count++;
+            derived();
+        });
+        expect(count).toBe(1);
+        set(1);
+        expect(count).toBe(2);
+        set(1);
+        expect(count).toBe(2);
+        set(0);
+        expect(count).toBe(3);
+    });
+    it("signal values are not deep diffed for equality", () => {
+        const [get, set] = createSignal({ a: 0, b: [1, 2, 3], c: { d: 4 } });
+        let count = 0;
+        createEffect(() => {
+            count++;
+            get();
+        });
+        expect(count).toBe(1);
+        set({ a: 0, b: [1, 2, 3], c: { d: 5 } });
+        expect(count).toBe(2);
+        set({ a: 0, b: [1, 2, 3], c: { d: 5 } });
+        expect(count).toBe(3);
+        set({ a: 0, b: [1, 2, 3], c: { d: 4 } });
+        expect(count).toBe(4);
+    });
+    it("await in effect prevents signal from being tracked", async () => {
+        const [get, set] = createSignal(0);
+        let count = 0;
+        // effect bumps count - depends on get() - never gets called again
+        createEffect(async () => {
+            count++;
+            await sleep(0);
+            get();
+        });
+        expect(count).toBe(1);
+        set(1);
+        expect(count).toBe(1);
+        await sleep(0);
+        set(2);
+        expect(count).toBe(1);
+    });
+    it("signal behind function call is tracked - same as derived", async () => {
+        const [get, set] = createSignal(0);
+        let count = 0;
+        const fn = () => get();
+        createEffect(async () => {
+            count++;
+            fn();
+        });
+        expect(count).toBe(1);
+        set(1);
+        expect(count).toBe(2);
+    });
+    it("memoizes values and updates them when signals change", () => {
+        const [get, set] = createSignal(0);
+        let count = 0;
+        const memo = createMemo(() => {
+            count++;
+            return `memo = ${2 * get()}`;
+        });
+        expect(count).toBe(1);
+        expect(memo()).toBe("memo = 0");
+        expect(count).toBe(1);
+        expect(memo()).toBe("memo = 0");
+        expect(count).toBe(1);
+        set(1);
+        expect(count).toBe(2);
+        expect(memo()).toBe("memo = 2");
+        set(1);
+        expect(count).toBe(2);
+        expect(memo()).toBe("memo = 2");
+        expect(count).toBe(2);
+        expect(memo()).toBe("memo = 2");
+        set(1000);
+        expect(count).toBe(3);
+        expect(memo()).toBe("memo = 2000");
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -34,14 +34,14 @@
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
     "@inlang/message": "2.1.0",
-    "@inlang/language-tag": "1.5.1",
     "@inlang/message-lint-rule": "1.4.5",
+    "@inlang/language-tag": "1.5.1",
+    "@inlang/module": "1.2.9",
     "@inlang/plugin": "2.4.9",
     "@inlang/project-settings": "2.4.0",
-    "@inlang/module": "1.2.9",
-    "@inlang/translatable": "1.3.1",
     "@inlang/result": "1.1.0",
-    "@lix-js/client": "1.1.0",
+    "@inlang/translatable": "1.3.1",
+    "@lix-js/client": "1.2.0",
     "@lix-js/fs": "1.0.0"
   },
   "devDependencies": {

package/src/loadProject.ts

@@ -37,7 +37,7 @@ import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectI
 
 import { capture } from "./telemetry/capture.js"
 import { identifyProject } from "./telemetry/groupIdentify.js"
-import type { NodeishStats } from "../../../../lix/source-code/fs/dist/NodeishFilesystemApi.js"
+import type { NodeishStats } from "@lix-js/fs"
 
 import _debug from "debug"
 const debug = _debug("loadProject")

package/src/reactivity/solid.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from "vitest"
+import { createSignal, createEffect, createMemo } from "./solid.js"
+
+function sleep(ms: number) {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+describe("solid", () => {
+	it("sets and gets", () => {
+		const [get, set] = createSignal(0)
+
+		expect(get()).toBe(0)
+		set(1)
+		expect(get()).toBe(1)
+	})
+
+	it("runs an effect whenn the signal value change", () => {
+		const [get, set] = createSignal(0)
+		let count = 0
+		createEffect(() => {
+			count++
+			get()
+		})
+		expect(count).toBe(1)
+		set(1)
+		expect(count).toBe(2)
+		set(1)
+		expect(count).toBe(2)
+		set(0)
+		expect(count).toBe(3)
+	})
+
+	it("runs an effect on a derived signal, when the underlying signal changes", () => {
+		const [get, set] = createSignal(0)
+		const derived = () => get() * 2
+		let count = 0
+		createEffect(() => {
+			count++
+			derived()
+		})
+		expect(count).toBe(1)
+		set(1)
+		expect(count).toBe(2)
+		set(1)
+		expect(count).toBe(2)
+		set(0)
+		expect(count).toBe(3)
+	})
+
+	it("signal values are not deep diffed for equality", () => {
+		const [get, set] = createSignal({ a: 0, b: [1, 2, 3], c: { d: 4 } })
+		let count = 0
+		createEffect(() => {
+			count++
+			get()
+		})
+		expect(count).toBe(1)
+		set({ a: 0, b: [1, 2, 3], c: { d: 5 } })
+		expect(count).toBe(2)
+		set({ a: 0, b: [1, 2, 3], c: { d: 5 } })
+		expect(count).toBe(3)
+		set({ a: 0, b: [1, 2, 3], c: { d: 4 } })
+		expect(count).toBe(4)
+	})
+
+	it("await in effect prevents signal from being tracked", async () => {
+		const [get, set] = createSignal(0)
+		let count = 0
+		// effect bumps count - depends on get() - never gets called again
+		createEffect(async () => {
+			count++
+			await sleep(0)
+			get()
+		})
+		expect(count).toBe(1)
+		set(1)
+		expect(count).toBe(1)
+		await sleep(0)
+		set(2)
+		expect(count).toBe(1)
+	})
+
+	it("signal behind function call is tracked - same as derived", async () => {
+		const [get, set] = createSignal(0)
+		let count = 0
+		const fn = () => get()
+		createEffect(async () => {
+			count++
+			fn()
+		})
+		expect(count).toBe(1)
+		set(1)
+		expect(count).toBe(2)
+	})
+
+	it("memoizes values and updates them when signals change", () => {
+		const [get, set] = createSignal(0)
+		let count = 0
+		const memo = createMemo(() => {
+			count++
+			return `memo = ${2 * get()}`
+		})
+		expect(count).toBe(1)
+		expect(memo()).toBe("memo = 0")
+		expect(count).toBe(1)
+		expect(memo()).toBe("memo = 0")
+		expect(count).toBe(1)
+		set(1)
+		expect(count).toBe(2)
+		expect(memo()).toBe("memo = 2")
+		set(1)
+		expect(count).toBe(2)
+		expect(memo()).toBe("memo = 2")
+		expect(count).toBe(2)
+		expect(memo()).toBe("memo = 2")
+		set(1000)
+		expect(count).toBe(3)
+		expect(memo()).toBe("memo = 2000")
+	})
+})