npm - round-core - Versions diffs - 0.0.5 → 0.0.7 - Mend

round-core 0.0.5 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/README.md +2 -2
package/dist/cli.js +49 -0
package/dist/index.d.ts +341 -0
package/dist/vite-plugin.js +0 -31
package/extension/.vscodeignore +5 -0
package/extension/LICENSE +21 -0
package/extension/cgmanifest.json +45 -0
package/extension/extension.js +163 -0
package/extension/images/round-config-dark.svg +10 -0
package/extension/images/round-config-light.svg +10 -0
package/extension/images/round-dark.svg +10 -0
package/extension/images/round-light.svg +10 -0
package/extension/javascript-language-configuration.json +241 -0
package/extension/package-lock.json +97 -0
package/extension/package.json +119 -0
package/extension/package.nls.json +4 -0
package/extension/round-0.1.0.vsix +0 -0
package/extension/round-lsp/package-lock.json +185 -0
package/extension/round-lsp/package.json +21 -0
package/extension/round-lsp/src/round-transformer-lsp.js +248 -0
package/extension/round-lsp/src/server.js +396 -0
package/extension/snippets/javascript.code-snippets +266 -0
package/extension/snippets/round.code-snippets +109 -0
package/extension/syntaxes/JavaScript.tmLanguage.json +6001 -0
package/extension/syntaxes/JavaScriptReact.tmLanguage.json +6066 -0
package/extension/syntaxes/Readme.md +12 -0
package/extension/syntaxes/Regular Expressions (JavaScript).tmLanguage +237 -0
package/extension/syntaxes/Round.tmLanguage.json +290 -0
package/extension/syntaxes/RoundInject.tmLanguage.json +20 -0
package/extension/tags-language-configuration.json +152 -0
package/extension/temp_astro/package-lock.json +912 -0
package/extension/temp_astro/package.json +16 -0
package/extension/types/round-core.d.ts +326 -0
package/package.json +2 -1
package/src/cli.js +53 -0
package/src/compiler/vite-plugin.js +0 -35
package/src/index.d.ts +341 -0
package/src/runtime/context.js +12 -0
package/src/runtime/dom.js +10 -0
package/src/runtime/router.js +28 -0
package/src/runtime/signals.js +38 -0
package/src/runtime/store.js +7 -0
package/vite.config.build.js +12 -0

package/README.md CHANGED Viewed

@@ -16,7 +16,7 @@
 npm install round-core
 ```
-Instead of a Virtual DOM diff, Round updates the UI by subscribing DOM updates directly to reactive primitives (**signals**). This keeps rendering predictable, small, and fast for interactive apps.
+Instead of a Virtual DOM diff, Round updates the UI by subscribing DOM updates directly to reactive primitives (**signals**) and **bindables**. This keeps rendering predictable, small, and fast for interactive apps.
 ## What Round is focused on
@@ -93,7 +93,7 @@ This scaffolds a minimal Round app with `src/app.round` and an example `src/coun
 ## `.round` files
-A `.round` file is a JSX-based component module (ESM) compiled by the Round toolchain.
+A `.round` file is a JSX-based component module (ESM) compiled by the Round toolchain. you can also use .jsx files but you wont get the round JSX superset features like conditional rendering and other features.
 Example `src/app.round`:

package/dist/cli.js CHANGED Viewed

@@ -10,6 +10,19 @@ function onSignal() {
 }
 process.on("SIGINT", onSignal);
 process.on("SIGTERM", onSignal);
+process.on("exit", () => {
+  cleanupTemporaryFiles();
+});
+const temporaryFiles = /* @__PURE__ */ new Set();
+function cleanupTemporaryFiles() {
+  for (const f of temporaryFiles) {
+    try {
+      if (fs.existsSync(f)) fs.unlinkSync(f);
+    } catch {
+    }
+  }
+  temporaryFiles.clear();
+}
 function normalizePath(p) {
   return p.replaceAll("\\", "/");
 }
@@ -323,6 +336,40 @@ function coerceNumber(v, fallback) {
   const n = Number(v);
   return Number.isFinite(n) ? n : fallback;
 }
+function generateIndexHtml(config) {
+  const name = config?.name ?? "Round";
+  const rawEntry = config?.entry ?? "./src/app.round";
+  let entry = rawEntry;
+  if (entry.startsWith("./")) entry = entry.slice(1);
+  if (!entry.startsWith("/")) entry = "/" + entry;
+  return [
+    "<!DOCTYPE html>",
+    '<html lang="en">',
+    "<head>",
+    '    <meta charset="UTF-8" />',
+    '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+    `    <title>${name}</title>`,
+    "</head>",
+    "<body>",
+    '    <div id="app"></div>',
+    '    <script type="module">',
+    "        import { render } from 'round-core';",
+    `        import App from '${entry}';`,
+    "",
+    "        render(App, document.getElementById('app'));",
+    "    <\/script>",
+    "</body>",
+    "</html>"
+  ].join("\n");
+}
+function writeTemporaryIndex(rootDir, config) {
+  const indexPath = path.resolve(rootDir, "index.html");
+  if (fs.existsSync(indexPath)) return false;
+  const content = generateIndexHtml(config);
+  fs.writeFileSync(indexPath, content, "utf8");
+  temporaryFiles.add(indexPath);
+  return true;
+}
 async function runDev({ rootDir, configPathAbs, config }) {
   const startedAt = Date.now();
   const configDir = path.dirname(configPathAbs);
@@ -344,6 +391,7 @@ async function runDev({ rootDir, configPathAbs, config }) {
     const serverPort2 = coerceNumber(nextConfig?.dev?.port, 5173);
     const open2 = Boolean(nextConfig?.dev?.open);
     const base2 = nextConfig?.routing?.base ?? "/";
+    writeTemporaryIndex(rootDir, nextConfig);
     if (showBanner) {
       banner();
       process.stdout.write(`${c("  Config", "gray")}  ${configPathAbs}
@@ -413,6 +461,7 @@ async function runBuild({ rootDir, configPathAbs, config }) {
   normalizePath(path.relative(rootDir, entryAbs));
   const outDir = config?.output ? resolveFrom(configDir, config.output) : resolveFrom(rootDir, "./dist");
   const base = config?.routing?.base ?? "/";
+  writeTemporaryIndex(rootDir, config);
   banner();
   process.stdout.write(`${c("  Config", "gray")}  ${configPathAbs}
 `);

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,341 @@
+/**
+ * Round Framework Type Definitions
+ */
+export interface RoundSignal<T> {
+    /**
+     * Get or set the current value.
+     */
+    (newValue?: T): T;
+    /**
+     * Get the current value (reactive).
+     */
+    value: T;
+    /**
+     * Get the current value without tracking dependencies.
+     */
+    peek(): T;
+    /**
+     * Creates a transformed view of this signal.
+     */
+    transform<U>(fromInput: (v: U) => T, toOutput: (v: T) => U): RoundSignal<U>;
+    /**
+     * Attaches validation logic to the signal.
+     */
+    validate(validator: (next: T, prev: T) => string | boolean | undefined | null, options?: {
+        /** Timing of validation: 'input' (default) or 'blur'. */
+        validateOn?: 'input' | 'blur';
+        /** Whether to run validation immediately on startup. */
+        validateInitial?: boolean;
+    }): RoundSignal<T> & {
+        /** Signal containing the current validation error message. */
+        error: RoundSignal<string | null>;
+        /** Manually trigger validation check. Returns true if valid. */
+        check(): boolean
+    };
+    /**
+     * Creates a read/write view of a specific property path.
+     */
+    $pick<K extends keyof T>(path: K): RoundSignal<T[K]>;
+    $pick(path: string | string[]): RoundSignal<any>;
+    /**
+     * Internal: marks the signal as bindable for two-way bindings.
+     */
+    bind?: boolean;
+}
+export interface Signal {
+    <T>(initialValue?: T): RoundSignal<T>;
+    object<T extends object>(initialState: T): { [K in keyof T]: RoundSignal<T[K]> };
+}
+/**
+ * Creates a reactive signal.
+ */
+export const signal: Signal;
+/**
+ * Creates a bindable signal intended for two-way DOM bindings.
+ */
+export interface Bindable {
+    <T>(initialValue?: T): RoundSignal<T>;
+    object<T extends object>(initialState: T): { [K in keyof T]: RoundSignal<T[K]> };
+}
+/**
+ * Creates a bindable signal intended for two-way DOM bindings.
+ */
+export const bindable: Bindable;
+/**
+ * Run a function without tracking any signals it reads.
+ * Any signals accessed inside the function will not become dependencies of the current effect.
+ */
+export function untrack<T>(fn: () => T): T;
+/**
+ * Create a reactive side-effect that runs whenever its signal dependencies change.
+ */
+export function effect(fn: () => void | (() => void), options?: {
+    /** If false, the effect won't run immediately on creation. Defaults to true. */
+    onLoad?: boolean
+}): () => void;
+/**
+ * Create a reactive side-effect with explicit dependencies.
+ */
+export function effect(deps: any[], fn: () => void | (() => void), options?: {
+    /** If false, the effect won't run immediately on creation. Defaults to true. */
+    onLoad?: boolean
+}): () => void;
+/**
+ * Create a read-only computed signal derived from other signals.
+ */
+export function derive<T>(fn: () => T): () => T;
+/**
+ * Create a read/write view of a specific path within a signal object.
+ */
+export function pick<T = any>(root: RoundSignal<any>, path: string | string[]): RoundSignal<T>;
+/**
+ * Store API
+ */
+export interface RoundStore<T> {
+    /**
+     * Access a specific key from the store as a bindable signal.
+     */
+    use<K extends keyof T>(key: K): RoundSignal<T[K]>;
+    /**
+     * Update a specific key in the store.
+     */
+    set<K extends keyof T>(key: K, value: T[K]): T[K];
+    /**
+     * Batch update multiple keys in the store.
+     */
+    patch(obj: Partial<T>): void;
+    /**
+     * Get a snapshot of the current state.
+     */
+    snapshot(options?: {
+        /** If true, the returned values will be reactive signals. */
+        reactive?: boolean
+    }): T;
+    /**
+     * Enable persistence for the store.
+     */
+    persist(storageKey: string, options?: {
+        /** The storage implementation (defaults to localStorage). */
+        storage?: Storage;
+        /** Debounce time in milliseconds for writes. */
+        debounce?: number;
+        /** Array of keys to exclude from persistence. */
+        exclude?: string[];
+    }): RoundStore<T>;
+    /**
+     * Action methods defined during store creation.
+     */
+    actions: Record<string, Function>;
+}
+/**
+ * Create a shared global state store with actions and optional persistence.
+ */
+export function createStore<T, A extends Record<string, (state: T, ...args: any[]) => Partial<T> | void>>(
+    initialState: T,
+    actions?: A
+): RoundStore<T> & { [K in keyof A]: (...args: Parameters<A[K]> extends [any, ...infer P] ? P : never) => any };
+/**
+ * Router API
+ */
+export interface RouteProps {
+    /** The path to match. Must start with a forward slash. */
+    route?: string;
+    /** If true, only matches if the path is exactly the same. */
+    exact?: boolean;
+    /** Page title to set in the document header when active. */
+    title?: string;
+    /** Meta description to set in the document header when active. */
+    description?: string;
+    /** Advanced head configuration including links and meta tags. */
+    head?: any;
+    /** Fragment or elements to render when matched. */
+    children?: any;
+}
+/**
+ * Define a route that renders its children when the path matches.
+ */
+export function Route(props: RouteProps): any;
+/**
+ * An alias for Route, typically used for top-level pages.
+ */
+export function Page(props: RouteProps): any;
+export interface LinkProps {
+    /** The destination path. */
+    href: string;
+    /** Alias for href. */
+    to?: string;
+    /** Use SPA navigation (prevents full page reloads). Defaults to true. */
+    spa?: boolean;
+    /** Force a full page reload on navigation. */
+    reload?: boolean;
+    /** Custom click event handler. */
+    onClick?: (e: MouseEvent) => void;
+    /** Link content (text or elements). */
+    children?: any;
+    [key: string]: any;
+}
+/**
+ * A standard link component that performs SPA navigation.
+ */
+export function Link(props: LinkProps): any;
+/**
+ * Define a fallback component or content for when no routes match.
+ */
+export function NotFound(props: {
+    /** Optional component to render for the 404 state. */
+    component?: any;
+    /** Fallback content. ignored if 'component' is provided. */
+    children?: any
+}): any;
+/**
+ * Navigate to a different path programmatically.
+ */
+export function navigate(to: string, options?: {
+    /** If true, replaces the current history entry instead of pushing. */
+    replace?: boolean
+}): void;
+/**
+ * Hook to get a reactive function returning the current normalized pathname.
+ */
+export function usePathname(): () => string;
+/**
+ * Get the current normalized pathname.
+ */
+export function getPathname(): string;
+/**
+ * Hook to get a reactive function returning the current location object.
+ */
+export function useLocation(): () => { pathname: string; search: string; hash: string };
+/**
+ * Get the current location object (pathname, search, hash).
+ */
+export function getLocation(): { pathname: string; search: string; hash: string };
+/**
+ * Hook to get a reactive function returning whether the current path has no matches.
+ */
+export function useIsNotFound(): () => boolean;
+/**
+ * Get whether the current path is NOT matched by any defined route.
+ */
+export function getIsNotFound(): boolean;
+/**
+ * DOM & Context API
+ */
+/**
+ * Create a DOM element or instance a component.
+ */
+export function createElement(tag: any, props?: any, ...children: any[]): any;
+/**
+ * A grouping component that returns its children without a wrapper element.
+ */
+export function Fragment(props: { children?: any }): any;
+export interface Context<T> {
+    /** Internal identifier for the context. */
+    id: number;
+    /** Default value used when no Provider is found in the tree. */
+    defaultValue: T;
+    /** Component that provides a value to all its descendants. */
+    Provider: (props: { value: T; children?: any }) => any;
+}
+/**
+ * Create a new Context object for sharing state between components.
+ */
+export function createContext<T>(defaultValue?: T): Context<T>;
+/**
+ * Read the current value of a context from the component tree.
+ */
+export function readContext<T>(ctx: Context<T>): T;
+/**
+ * Returns a reactive function that reads the current context value.
+ */
+export function bindContext<T>(ctx: Context<T>): () => T;
+/**
+ * Async & Code Splitting
+ */
+/**
+ * Mark a component for lazy loading (code-splitting).
+ * Expects a function returning a dynamic import promise.
+ */
+export function lazy<T>(fn: () => Promise<{ default: T } | T>): any;
+declare module "*.round";
+export interface SuspenseProps {
+    /** Content to show while children (e.g. lazy components) are loading. */
+    fallback: any;
+    /** Content that might trigger a loading state. */
+    children?: any;
+}
+/**
+ * Component that boundaries async operations and renders a fallback while loading.
+ */
+export function Suspense(props: SuspenseProps): any;
+/**
+ * Head Management
+ */
+/**
+ * Define static head metadata (titles, meta tags, favicons, etc.).
+ */
+export function startHead(head: any): any;
+/**
+ * Markdown
+ */
+/**
+ * Component that renders Markdown content into HTML.
+ */
+export function Markdown(props: {
+    /** The markdown string or a function returning it. */
+    content: string | (() => string);
+    /** Remark/Rehype configuration options. */
+    options?: any
+}): any;

package/dist/vite-plugin.js CHANGED Viewed

@@ -614,40 +614,9 @@ ${head.raw}`;
       };
     },
     resolveId(id) {
-      if (id === "/index.html" || id === "index.html") {
-        const fullPath = path.resolve(state.rootDir, "index.html");
-        if (!fs.existsSync(fullPath)) {
-          return "/index.html";
-        }
-      }
       return null;
     },
     load(id) {
-      if (id === "/index.html" || id === "index.html") {
-        const fullPath = path.resolve(state.rootDir, "index.html");
-        if (fs.existsSync(fullPath)) return null;
-        const entry = state.entryRel ?? "./src/index.js";
-        const entryPath = entry.startsWith("/") ? entry : `/${entry}`;
-        return [
-          "<!DOCTYPE html>",
-          '<html lang="en">',
-          "<head>",
-          '    <meta charset="UTF-8" />',
-          '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
-          `    <title>${state.name}</title>`,
-          "</head>",
-          "<body>",
-          '    <div id="app"></div>',
-          '    <script type="module">',
-          "        import { render } from 'round-core';",
-          `        import App from '${entryPath}';`,
-          "",
-          "        render(App, document.getElementById('app'));",
-          "    <\/script>",
-          "</body>",
-          "</html>"
-        ].join("\n");
-      }
       if (!isMdRawRequest(id)) return;
       const fileAbs = stripQuery(id);
       try {

package/extension/.vscodeignore ADDED Viewed

@@ -0,0 +1,5 @@
+test/**
+src/**/*.ts
+syntaxes/Readme.md
+tsconfig.json
+cgmanifest.json

package/extension/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2025 ZtaMDev
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/extension/cgmanifest.json ADDED Viewed

@@ -0,0 +1,45 @@
+{
+	"registrations": [
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "microsoft/TypeScript-TmLanguage",
+					"repositoryUrl": "https://github.com/microsoft/TypeScript-TmLanguage",
+					"commitHash": "3133e3d914db9a2bb8812119f9273727a305f16b"
+				}
+			},
+			"license": "MIT",
+			"version": "0.0.1",
+			"description": "The file syntaxes/JavaScript.tmLanguage.json was derived from TypeScriptReact.tmLanguage in https://github.com/microsoft/TypeScript-TmLanguage."
+		},
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "textmate/javascript.tmbundle",
+					"repositoryUrl": "https://github.com/textmate/javascript.tmbundle",
+					"commitHash": "fccf0af0c95430a42e1bf98f0c7a4723a53283e7"
+				}
+			},
+			"licenseDetail": [
+				"Copyright (c) textmate-javascript.tmbundle project authors",
+				"",
+				"If not otherwise specified (see below), files in this repository fall under the following license:",
+				"",
+				"Permission to copy, use, modify, sell and distribute this",
+				"software is granted. This software is provided \"as is\" without",
+				"express or implied warranty, and with no claim as to its",
+				"suitability for any purpose.",
+				"",
+				"An exception is made for files in readable text which contain their own license information,",
+				"or files where an accompanying file exists (in the same directory) with a \"-license\" suffix added",
+				"to the base-name name of the original file, and an extension of txt, html, or similar. For example",
+				"\"tidy\" is accompanied by \"tidy-license.txt\"."
+			],
+			"license": "TextMate Bundle License",
+			"version": "0.0.0"
+		}
+	],
+	"version": 1
+}