You have a new contract: conceptualize, design, and create a lightweight JavaScript UI…
- User
You have a new contract: conceptualize, design, and create a lightweight JavaScript UI engine that efficiently manages components, data structures, and state. Use only pure low-level JavaScript, Web Components, and modern Web APIs the highest performance.
Introduction to Cat.js blueprint. Our engine, named by the name of the animal for its known lightness, flexibility and accuracy, looks to outperform current solutions, like Svelte.
Unlike React, Svelte, Angular, and similar frameworks, our engine operates in a vanilla environment without the need for bundles, polyfills, or Webpack. It avoids inefficient practices associated with virtual DOMs, as well as unnecessary reflows and repaints, such as rebuilding or re-rendering an entire component just to update a single element.
Our engine needs to be lightweight, user-friendly, and highly optimized, leveraging raw, low-level JavaScript knowledge tailored to modern browser runtimes. It is designed specifically for creating robust and efficient user interfaces for Tauri-based applications, without the need for bundlers.
Our primary reference it's Svelte, I like how they manage the concept of "Reactivity". But, our engine instead of Svelte, which is a framework, it's going to specialize and focus only on UI, components and data management.
Technical expectative:
- Pure raw JavaScript for the motor of the engine.
- An architecture thought carefully to fit the browser JS runtime.
- SOTA Memory usage.
- Ease to use API and Syntax
- SOTA Reactive engine.
- Design a new ease way to import components into the DOM.
Syntax expectative:
<template name="cat-note" id="Note"> <div> <textarea @input="update" id="content">{content}</textarea> </div> </template> <script> let serial = 00832; let content = serial + text; update(newText) { text = newText; } </script><!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>CAT Demo</title> <script src="/app/cat.js"></script> </head> <body> <cat-note></cat-note> </body> </html>The code above it's a matter of desired reference, a vision I'd like to try to achieve, but as the expert and on charge of the development of this engine, you must base your decisions and actions on factual data about our context, environment and desired performance and simplicity goals.
Invest all the time needed thinking and designing such engine, and output an initial version, functional and robust.
For debugging, we'll test it with a single note component, but used two times, and when I'll write on the left note, the right note display the same content but backwards. This debugging case must show the potential of our engine, and it's simplicity.
- Assistant
Cat.js - A Lightweight JavaScript UI Engine
Introduction
Cat.js is a lightweight JavaScript UI engine designed to efficiently manage components, data structures, and state using pure low-level JavaScript, Web Components, and modern Web APIs. It operates without the need for bundlers, polyfills, or Webpack, avoiding inefficient practices like virtual DOMs and unnecessary reflows/repaints. Cat.js focuses solely on UI, components, and data management, providing a simple and performant solution for building robust user interfaces, especially suited for Tauri-based applications.
Design Principles
- Pure JavaScript Core: Cat.js uses only pure JavaScript without any dependencies or build tools.
- Optimized Architecture: Carefully designed to fit the browser's JavaScript runtime for optimal performance.
- State-of-the-Art (SOTA) Memory Usage: Efficient memory management to ensure lightweight performance.
- Simple API and Syntax: Easy-to-use syntax inspired by modern frameworks but simplified for direct browser usage.
- Reactive Engine: Implements a reactive system to update the UI efficiently when the state changes.
- Component Importation: Provides a straightforward method to import and use components in the DOM.
Implementation
1. Cat.js Engine (
cat.js)// cat.js (function() { // Collect all templates with a 'name' attribute const templates = document.querySelectorAll('template[name]'); templates.forEach(template => { const name = template.getAttribute('name'); // Find the associated script element let script = template.nextElementSibling; while (script && script.tagName.toLowerCase() !== 'script') { script = script.nextElementSibling; } if (!script) { console.error(`No script found for component ${name}`); return; } // Define the custom element class class Component extends HTMLElement { constructor() { super(); // Create a shadow root this.attachShadow({ mode: 'open' }); // Store the template content this.templateContent = template.innerHTML.trim(); // Initialize component state and set up reactivity this.state = {}; this.setupReactivity(); // Initialize methods and state from the script content this.initScript(script.textContent); // Render the component this.render(); // Set up event listeners for inter-component communication this.setupEventListeners(); } initScript(scriptContent) { const func = new Function('component', scriptContent); func.call(this.proxyState, this); } setupReactivity() { const self = this; this.proxyState = new Proxy(this.state, { set(target, prop, value) { target[prop] = value; self.update(); return true; } }); } bindEvents() { const self = this; const nodes = this.shadowRoot.querySelectorAll('[\\@input]'); nodes.forEach(node => { const eventHandler = node.getAttribute('@input'); node.addEventListener('input', (e) => { if (typeof self.proxyState[eventHandler] === 'function') { self.proxyState[eventHandler].call(self.proxyState, e.target.value); } }); }); } render() { // Render the template with the current state const renderedHtml = this.interpolate(this.templateContent, this.proxyState); this.shadowRoot.innerHTML = renderedHtml; this.bindEvents(); } update() { // Re-render the component when the state changes this.render(); } interpolate(template, state) { return template.replace(/\{(.*?)\}/g, (match, p1) => { const keys = p1.trim().split('.'); let value = state; keys.forEach(key => { value = value[key]; }); return value ?? ''; }); } setupEventListeners() { // Listen for custom events from other components this.addEventListener('noteUpdated', (e) => { if (e.target !== this) { // Update the component's state with reversed text this.proxyState.text = e.detail.text.split('').reverse().join(''); this.proxyState.content = this.proxyState.serial + this.proxyState.text; } }); } } // Register the custom element customElements.define(name, Component); }); })();
2. Note Component (
note.html)<!-- note.html --> <template name="cat-note" id="Note"> <div> <textarea @input="update" id="content">{content}</textarea> </div> </template> <script> this.serial = 832; this.text = ''; this.content = this.serial + this.text; this.update = function(newText) { this.text = newText; this.content = this.serial + this.text; // Dispatch a custom event to other components const event = new CustomEvent('noteUpdated', { detail: { text: this.text }, bubbles: true, composed: true }); component.dispatchEvent(event); }; </script>
3. Main HTML File (
index.html)<!-- index.html --> <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Cat.js Demo</title> <!-- Include Cat.js --> <script src="cat.js" defer></script> <!-- Include the Note component --> <link rel="import" href="note.html"> </head> <body> <cat-note></cat-note> <cat-note></cat-note> </body> </html>
How It Works
Component Definition
Components are defined using a
<template>element with anameattribute and an associated<script>:<template name="cat-note"> <!-- Component's HTML structure --> </template> <script> // Component's state and methods </script>State Initialization and Reactivity
- State Initialization: The script associated with the template initializes the component's state variables and methods.
- Reactivity: A
Proxywraps the state object to detect changes. When a state property is updated, the component automatically re-renders.
Event Handling
- Custom Event Attributes: Events are bound using custom attributes like
@input="update", associating DOM events with methods in the script. - Event Binding Function: The
bindEventsfunction attaches event listeners to elements with custom event attributes.
Data Binding
- Template Interpolation: The
{variable}syntax in the template is used to bind state variables to the component's HTML. - Interpolation Function: The
interpolatefunction replaces placeholders with the current state values during rendering.
Inter-Component Communication
- Custom Events: Components communicate by dispatching and listening to custom events.
- Event Dispatching: The
updatemethod dispatches anoteUpdatedevent with the new text. - Event Listening: Components listen for
noteUpdatedevents from other instances and update their state accordingly.
Debugging Case Demonstration
In the
index.htmlfile, we include two instances of the<cat-note>component:<body> <cat-note></cat-note> <cat-note></cat-note> </body>Behavior:
- When you type into the first note's textarea, the second note updates to display the content reversed.
- This demonstrates the inter-component communication and reactivity of the engine.
Usage Guide
Defining a Component
-
Create a Template: Define the HTML structure within a
<template>element with a uniquenameattribute.<template name="my-component"> <!-- Component's HTML --> </template> -
Add a Script: Define the component's state and methods in a
<script>tag immediately following the template.<script> this.myState = 'Hello World'; this.myMethod = function() { // Method logic }; </script> -
Use Placeholders: Bind state variables to the template using
{variable}syntax.<template name="my-component"> <div>{myState}</div> </template> -
Bind Events: Use custom event attributes like
@click="myMethod"to bind DOM events to your methods.<button @click="myMethod">Click Me</button>
Including Components
-
Script Inclusion: Include
cat.jsin your main HTML file.<script src="cat.js" defer></script> -
Component Import: Import your component file(s).
<link rel="import" href="my-component.html"> -
Using Components: Use your custom component as a regular HTML element.
<my-component></my-component>
Conclusion
Cat.js provides a simple yet powerful way to build reactive UI components without the overhead of large frameworks or build tools. By leveraging modern Web APIs and pure JavaScript, it offers excellent performance and a streamlined development experience.
- Performance: Direct DOM manipulation and efficient state management ensure high performance.
- Simplicity: Minimal syntax and straightforward component definitions make it easy to use.
- Flexibility: Easily extendable and adaptable to various use cases.
Future Improvements
- Enhanced Data Binding: Implementing more advanced data-binding features, such as conditional rendering and list rendering.
- Lifecycle Methods: Introducing lifecycle hooks for better control over component rendering and updates.
- Module Loading: Exploring dynamic module loading to improve component import mechanisms.
Note: This is an initial version of Cat.js aimed at showcasing its potential and simplicity. Further optimization and feature enhancements can be built upon this foundation.