round-core 0.0.4 → 0.0.6

package/src/runtime/signals.js

@@ -12,6 +12,13 @@ function subscribe(running, subscriptions) {
     running.dependencies.add(subscriptions);
 }
 
+/**
+ * Run a function without tracking any signals it reads.
+ * Any signals accessed inside `fn` will not become dependencies of the current effect.
+ * @template T
+ * @param {() => T} fn The function to execute.
+ * @returns {T} The return value of `fn`.
+ */
 export function untrack(fn) {
     context.push(null);
     try {
@@ -21,6 +28,13 @@ export function untrack(fn) {
     }
 }
 
+/**
+ * Create a reactive side-effect that runs whenever its signal dependencies change.
+ * @param {(() => any) | any[]} arg1 Either the callback function or an array of explicit dependencies.
+ * @param {(() => any)} [arg2] The callback function if the first argument was explicit dependencies.
+ * @param {object} [arg3] Optional configuration (e.g., { onLoad: false }).
+ * @returns {() => void} A function to stop and cleanup the effect.
+ */
 export function effect(arg1, arg2, arg3) {
     let callback;
     let explicitDeps = null;
@@ -241,6 +255,12 @@ function attachHelpers(s) {
     return s;
 }
 
+/**
+ * Create a reactive signal.
+ * @template T
+ * @param {T} [initialValue] The starting value.
+ * @returns {RoundSignal<T>} A signal function that reads/writes the value.
+ */
 export function signal(initialValue) {
     let value = initialValue;
     const subscriptions = new Set();
@@ -285,6 +305,12 @@ export function signal(initialValue) {
     return attachHelpers(signal);
 }
 
+/**
+ * Create a bindable signal intended for two-way DOM bindings.
+ * @template T
+ * @param {T} [initialValue] The starting value.
+ * @returns {RoundSignal<T>} A signal function marked as bindable.
+ */
 export function bindable(initialValue) {
     const s = signal(initialValue);
     try {
@@ -345,6 +371,12 @@ function parsePath(path) {
     return [String(path)];
 }
 
+/**
+ * Create a read/write view of a specific path within a signal object.
+ * @param {RoundSignal<any>} root The source signal.
+ * @param {string | string[]} path The property path (e.g., 'user.profile.name' or ['user', 'profile', 'name']).
+ * @returns {RoundSignal<any>} A signal-like view of the path.
+ */
 export function pick(root, path) {
     if (!isSignalLike(root)) {
         throw new Error('[round] pick(root, path) expects root to be a signal (use bindable.object(...) or signal({...})).');
@@ -499,6 +531,12 @@ bindable.object = function (initialObject = {}) {
     return createBindableObjectProxy(root, []);
 };
 
+/**
+ * Create a read-only computed signal derived from other signals.
+ * @template T
+ * @param {() => T} fn A function that computes the value.
+ * @returns {(() => T)} A function that returns the derived value.
+ */
 export function derive(fn) {
     const derived = signal();
 

package/src/runtime/store.js

@@ -5,6 +5,13 @@ function hasWindow() {
     return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 
+/**
+ * Create a shared global state store with actions and optional persistence.
+ * @template T
+ * @param {T} [initialState={}] Initial state object.
+ * @param {Record<string, (state: T, ...args: any[]) => any>} [actions] Action reducers.
+ * @returns {RoundStore<T>} The store object.
+ */
 export function createStore(initialState = {}, actions = null) {
     const state = (initialState && typeof initialState === 'object') ? initialState : {};
     const signals = Object.create(null);

package/vite.config.build.js

@@ -2,32 +2,21 @@ import { defineConfig } from 'vite';
 import path from 'node:path';
 import fs from 'node:fs';
 
-// Custom plugin to move .d.ts files or raw assets if needed, 
-// for now we just handle JS bundling.
-
-// Custom plugin to move .d.ts files or raw assets if needed, 
-// for now we just handle JS bundling.
-
 export default defineConfig({
     build: {
-        // Target modern environments
         target: 'es2022',
         outDir: 'dist',
         emptyOutDir: true,
-        minify: false, // User can enable if they want extreme minification, but for a lib readable code is nice. 
-        // Wait, user asked for "extremo rapido y liviano" (extremely fast and light). 
-        // So I SHOULD minify.
+        minify: false,
         lib: {
             entry: {
                 index: path.resolve(__dirname, 'src/index.js'),
                 cli: path.resolve(__dirname, 'src/cli.js'),
-                // We expose the plugin separately so users can import it in their vite.config.js
                 'vite-plugin': path.resolve(__dirname, 'src/compiler/vite-plugin.js')
             },
-            formats: ['es'] // ESM only is fine for modern "type": "module" package
+            formats: ['es']
         },
         rollupOptions: {
-            // Externalize dependencies so they aren't bundled into the library
             external: [
                 'vite',
                 'marked',
@@ -44,4 +33,16 @@ export default defineConfig({
             }
         },
     },
+    plugins: [
+        {
+            name: 'copy-dts',
+            closeBundle() {
+                const src = path.resolve(__dirname, 'src/index.d.ts');
+                const dest = path.resolve(__dirname, 'dist/index.d.ts');
+                if (fs.existsSync(src)) {
+                    fs.copyFileSync(src, dest);
+                }
+            }
+        }
+    ]
 });

package/index.html

@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <title>Round Vite Test</title>
-</head>
-
-<body>
-    <div id="app"></div>
-    <script type="module">
-        import { render } from '/index.js';
-        import TestApp from 'start_exmpl/TestApp.round';
-
-        render(TestApp, document.getElementById('app'));
-    </script>
-</body>
-
-</html>