redweb 0.16.2 → 0.16.4

package/src/htmx/PageTaskLane.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/** Serializes all browser work for one live page, regardless of transport. */
+class PageTaskLane {
+    constructor(maxPending = 64) {
+        this.maxPending = maxPending;
+        this.tasks = [];
+        this.running = false;
+        this.closed = false;
+    }
+
+    enqueue(task) {
+        if (typeof task !== 'function') throw new TypeError('Page tasks must be functions.');
+        if (this.closed || this.tasks.length + (this.running ? 1 : 0) >= this.maxPending) return null;
+        let resolve, reject;
+        const result = new Promise((accept, deny) => { resolve = accept; reject = deny; });
+        this.tasks.push({ task, resolve, reject });
+        if (!this.running) void this.drain();
+        return result;
+    }
+
+    async drain() {
+        this.running = true;
+        while (!this.closed && this.tasks.length) {
+            const current = this.tasks.shift();
+            try { current.resolve(await current.task()); }
+            catch (error) { current.reject(error); }
+        }
+        this.running = false;
+    }
+
+    close(error = new Error('Page task lane closed.')) {
+        if (this.closed) return;
+        this.closed = true;
+        this.tasks.splice(0).forEach(task => task.reject(error));
+    }
+}
+
+module.exports = PageTaskLane;

package/src/htmx/ReactiveRenderer.js

@@ -222,14 +222,14 @@ class ReactiveRenderer {
             const node = this.nodes.get(ownerId(payload.component));
             return node && [...node.html.matchAll(/\b(?:data-rw-state|rw-bind)\s*=\s*["']([^"']+)["']/g)].some(match => match[1] === payload.name);
         });
-        if (!this.disposed && generation === this.generation && socket && (patches.length || explicit.length)) {
-            try { if (this.authorize) await this.authorize(); }
-            catch (error) {
-                if (this.disposed || generation !== this.generation) return;
-                throw error;
-            }
-            if (this.disposed || generation !== this.generation) return;
-            socket.sendEvent('redweb:patch', { patches, states: explicit });
+        if (!this.disposed && generation === this.generation && socket && (patches.length || explicit.length)) {
+            try { if (this.authorize) await this.authorize(); }
+            catch (error) {
+                if (this.disposed || generation !== this.generation) return;
+                throw error;
+            }
+            if (this.disposed || generation !== this.generation) return;
+            socket.sendEvent('redweb:patch', { patches, states: explicit });
         }
     }
 

package/src/htmx/SocketAction.js

@@ -1,19 +1,19 @@
-'use strict';
-
-const { AsyncLocalStorage } = require('async_hooks');
-const { bindings } = require('../ws/SocketAction');
-const routes = new AsyncLocalStorage();
-
-function attributes(properties) {
-    let result = properties;
-    for (const name of ['rw-click', 'rw-submit']) {
-        const binding = bindings.get(properties[name]);
-        if (!binding) continue;
-        if (!routes.getStore()?.has(binding.Handler)) throw new TypeError('Socket action handler must belong to this page socket route.');
-        if (Object.keys(result).some(key => key.toLowerCase() === 'data-rw-command')) throw new TypeError('Only one socket action may bind a control.');
-        result = { ...result, [name]: binding.type, 'data-rw-command': JSON.stringify({ type: binding.type, payload: binding.payload }) };
-    }
-    return result;
-}
-
-module.exports = { attributes, withRoute: (handlers, render) => routes.run(handlers, render) };
+'use strict';
+
+const { AsyncLocalStorage } = require('async_hooks');
+const { bindings } = require('../ws/SocketAction');
+const routes = new AsyncLocalStorage();
+
+function attributes(properties) {
+    let result = properties;
+    for (const name of ['rw-click', 'rw-submit']) {
+        const binding = bindings.get(properties[name]);
+        if (!binding) continue;
+        if (!routes.getStore()?.has(binding.Handler)) throw new TypeError('Socket action handler must belong to this page socket route.');
+        if (Object.keys(result).some(key => key.toLowerCase() === 'data-rw-command')) throw new TypeError('Only one socket action may bind a control.');
+        result = { ...result, [name]: binding.type, 'data-rw-command': JSON.stringify({ type: binding.type, payload: binding.payload }) };
+    }
+    return result;
+}
+
+module.exports = { attributes, withRoute: (handlers, render) => routes.run(handlers, render) };

package/src/htmx/TemplateRenderer.js

@@ -13,7 +13,7 @@ const BINDING = /{{\s*([A-Za-z_$][\w$]*)\s*}}/g;
 const ATTRIBUTE_BINDING = /{{\s*[A-Za-z_$][\w$]*\s*}}/;
 const NAME = /^[A-Za-z_$][\w$]*$/;
 const DIRECTIVES = new Set(['data-rw-state', 'data-rw-html', 'rw-each']);
-const COMPONENT_DIRECTIVES = new Set(['data-rw-component', 'data-rw-state', 'rw-bind', 'rw-click', 'rw-submit', 'rw-status']);
+const COMPONENT_DIRECTIVES = new Set(['data-rw-component', 'data-rw-state', 'rw-bind', 'rw-click', 'rw-submit', 'rw-upload', 'rw-paste', 'rw-status']);
 
 function attributes(tag, nameEnd, tracked = DIRECTIVES) {
     const found = new Map();

package/src/htmx/index.js

@@ -2,9 +2,11 @@ const HtmlRenderer = require('./HtmlRenderer');
 const LiveHtmlServer = require('./LiveHtmlServer');
 const LivePage = require('./LivePage');
 const { attribute, codeBlock, each, html, safeUrl: url } = require('./Html');
-const { action, component, page, state, view } = require('./metadata');
+const { highlightCode } = require('./CodeHighlight');
+const { action, component, inject, page, resource, state, upload, view } = require('./metadata');
+const { LiveResource, liveResource } = require('./LiveResource');
 const { start } = require('./start');
 const { exportStatic } = require('./StaticExporter');
 const { defineSite } = require('./StaticSite');
 
-module.exports = { action, attribute, codeBlock, component, defineSite, each, exportStatic, html, HtmlRenderer, LiveHtmlServer, LivePage, page, start, state, url, view };
+module.exports = { action, attribute, codeBlock, component, defineSite, each, exportStatic, highlightCode, html, HtmlRenderer, inject, LiveHtmlServer, LivePage, LiveResource, liveResource, page, resource, start, state, upload, url, view };

package/src/htmx/metadata.js

@@ -7,6 +7,12 @@ const STANDARD_ACTIONS = new WeakMap();
 const VIEW_METADATA = new WeakMap();
 const RESOLVED_VIEW = new WeakMap();
 const STANDARD_VIEWS = new WeakMap();
+const RESOURCE_METADATA = new WeakMap();
+const RESOLVED_RESOURCE = new WeakMap();
+const INJECT_METADATA = new WeakMap();
+const RESOLVED_INJECT = new WeakMap();
+const UPLOAD_METADATA = new WeakMap();
+const RESOLVED_UPLOAD = new WeakMap();
 const PAGE_ROOTS = new WeakMap();
 const PAGE_STYLESHEET_ROOTS = new WeakMap();
 const COMPONENT_CLASSES = new WeakSet();
@@ -65,6 +71,27 @@ function registerView(store, PageClass, stateName, method, implementation) {
     metadataVersion += 1;
 }
 
+function registerResource(PageClass, property, config) {
+    const properties = new Map(RESOURCE_METADATA.get(PageClass) || []);
+    properties.set(property, config);
+    RESOURCE_METADATA.set(PageClass, properties);
+    metadataVersion += 1;
+}
+
+function registerInject(PageClass, property, provider) {
+    const properties = new Map(INJECT_METADATA.get(PageClass) || []);
+    properties.set(property, provider);
+    INJECT_METADATA.set(PageClass, properties);
+    metadataVersion += 1;
+}
+
+function registerUpload(PageClass, method, config) {
+    const methods = new Map(UPLOAD_METADATA.get(PageClass) || []);
+    methods.set(method, config);
+    UPLOAD_METADATA.set(PageClass, methods);
+    metadataVersion += 1;
+}
+
 function resolvedState(PageClass) {
     const cached = RESOLVED_STATE.get(PageClass);
     if (cached?.version === metadataVersion) return cached.value;
@@ -112,6 +139,15 @@ function resolvedView(PageClass) {
     return value;
 }
 
+function resolved(store, cache, PageClass) {
+    const cached = cache.get(PageClass);
+    if (cached?.version === metadataVersion) return cached.value;
+    const value = new Map();
+    hierarchy(PageClass).forEach(CurrentClass => store.get(CurrentClass)?.forEach((config, property) => value.set(property, config)));
+    cache.set(PageClass, { version: metadataVersion, value });
+    return value;
+}
+
 function pageHead(value) {
     if (value === undefined) return undefined;
     if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('Page head must be an object.');
@@ -178,10 +214,10 @@ function page(routePath, options = {}) {
     if (!['connection', 'shared'].includes(scope)) {
         throw new TypeError('Page scope must be "connection" or "shared".');
     }
-    if (typeof live !== 'boolean') throw new TypeError('Page live must be a boolean.');
-    if (options.socket !== undefined && (typeof options.socket !== 'function' || !live || scope !== 'connection')) {
-        throw new TypeError('Page socket requires a route class and a live connection-scoped page.');
-    }
+    if (typeof live !== 'boolean') throw new TypeError('Page live must be a boolean.');
+    if (options.socket !== undefined && (typeof options.socket !== 'function' || !live || scope !== 'connection')) {
+        throw new TypeError('Page socket requires a route class and a live connection-scoped page.');
+    }
     if (layout !== undefined && typeof layout !== 'function') throw new TypeError('Page layout must be a function.');
     const head = pageHead(options.head);
     const cache = pageCache(options.cache, live);
@@ -192,8 +228,8 @@ function page(routePath, options = {}) {
         PAGE_METADATA.set(PageClass, Object.freeze({
             path: routePath,
             template,
-            scope,
-            ...(options.socket && { socket: options.socket }),
+            scope,
+            ...(options.socket && { socket: options.socket }),
             ...(live === false && { live: false }),
             ...(head && { head }),
             ...(cache && { cache }),
@@ -250,6 +286,71 @@ function state(options = {}) {
     };
 }
 
+function resource(liveResource, select) {
+    const { LiveResource } = require('./LiveResource');
+    if (!(liveResource instanceof LiveResource)) throw new TypeError('resource() requires a value created by liveResource().');
+    if (typeof select !== 'function') throw new TypeError('resource() requires a key selector.');
+    const config = Object.freeze({ resource: liveResource, select });
+    return (target, property) => {
+        if (property?.kind === 'field') {
+            if (property.static || property.private || typeof property.name !== 'string' || !property.name) {
+                throw new TypeError('resource() requires a public instance field with a string name.');
+            }
+            property.addInitializer(function registerStandardResource() {
+                registerState(this.constructor, property.name, Object.freeze({ writable: false }));
+                registerResource(this.constructor, property.name, config);
+            });
+            return initialValue => initialValue;
+        }
+        const PageClass = assertDecoratorTarget(target, 'resource()');
+        if (typeof property !== 'string' || !property) throw new TypeError('Resource property must be a non-empty string.');
+        registerState(PageClass, property, Object.freeze({ writable: false }));
+        registerResource(PageClass, property, config);
+    };
+}
+
+function inject(provider) {
+    if (typeof provider !== 'string' || !provider || provider.length > 128 || ['__proto__', 'prototype', 'constructor'].includes(provider)) {
+        throw new TypeError('inject() requires a safe non-empty provider name of at most 128 characters.');
+    }
+    return (target, property) => {
+        if (property?.kind === 'field') {
+            if (property.static || property.private || typeof property.name !== 'string' || !property.name) {
+                throw new TypeError('inject() requires a public instance field with a string name.');
+            }
+            property.addInitializer(function registerStandardInject() { registerInject(this.constructor, property.name, provider); });
+            return initialValue => initialValue;
+        }
+        const PageClass = assertDecoratorTarget(target, 'inject()');
+        if (typeof property !== 'string' || !property) throw new TypeError('Injected property must be a non-empty string.');
+        registerInject(PageClass, property, provider);
+    };
+}
+
+function upload(options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('upload() options must be an object.');
+    const { maxBytes = 10 * 1024 * 1024, accept = [] } = options;
+    if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 1024 * 1024 * 1024) throw new RangeError('upload() maxBytes must be an integer between 1 and 1 GiB.');
+    const types = Array.isArray(accept) ? accept : [accept];
+    if (types.some(type => typeof type !== 'string' || !/^[a-z]+\/(?:[a-z0-9.+-]+|\*)$/.test(type))) throw new TypeError('upload() accept must contain MIME types or type wildcards.');
+    const config = Object.freeze({ maxBytes, accept: Object.freeze([...new Set(types)]) });
+    return (target, method, descriptor) => {
+        if (method?.kind === 'method') {
+            if (method.static || method.private || typeof method.name !== 'string' || !method.name || typeof target !== 'function') throw new TypeError('upload() requires a public instance method with a string name.');
+            const entry = Object.freeze({ implementation: target, definition: new ActionDefinition() });
+            method.addInitializer(function registerStandardUpload() {
+                if (this[method.name] === target) { registerStandardAction(this.constructor, method.name, entry); registerUpload(this.constructor, method.name, config); }
+            });
+            return target;
+        }
+        const PageClass = assertDecoratorTarget(target, 'upload()');
+        if (typeof method !== 'string' || !method || typeof descriptor?.value !== 'function') throw new TypeError('upload() must decorate a method.');
+        registerAction(PageClass, method, Object.freeze({ implementation: descriptor.value, definition: new ActionDefinition() }));
+        registerUpload(PageClass, method, config);
+        return descriptor;
+    };
+}
+
 function action(options) {
     const definition = new ActionDefinition(options);
     return (target, method, descriptor) => {
@@ -321,6 +422,10 @@ function getStateConfig(PageClass, property) {
     return resolvedState(PageClass).get(property);
 }
 
+function getResourceMetadata(PageClass) { return new Map(resolved(RESOURCE_METADATA, RESOLVED_RESOURCE, PageClass)); }
+function getInjectMetadata(PageClass) { return new Map(resolved(INJECT_METADATA, RESOLVED_INJECT, PageClass)); }
+function getUploadMetadata(PageClass) { return new Map(resolved(UPLOAD_METADATA, RESOLVED_UPLOAD, PageClass)); }
+
 function forEachState(PageClass, callback) {
     resolvedState(PageClass).forEach(callback);
 }
@@ -349,6 +454,9 @@ module.exports = {
     getActionDefinition,
     getActionMetadata,
     getPageMetadata,
+    getInjectMetadata,
+    getUploadMetadata,
+    getResourceMetadata,
     getPageStylesheetRoots,
     getPageTemplateRoot,
     getStateConfig,
@@ -356,10 +464,13 @@ module.exports = {
     getViewImplementation,
     getViewMetadata,
     isComponentClass,
+    inject,
     page,
     pageCache,
     pageHead,
     setPageStylesheetRoots,
     state,
+    resource,
+    upload,
     view,
 };

package/src/ws/BaseHandler.js

@@ -20,12 +20,12 @@ class BaseHandler {
      */
     async handleMessage(socket, message) {
         const validationResult = await this.validateMessage(message, socket);
-        if (validationResult === false) {
-            throw new Error('Invalid message');
-        }
-        const guard = require('./HandlerGuard').guards.get(socket);
-        if (guard) await guard();
-        return this.onMessage(socket, message);
+        if (validationResult === false) {
+            throw new Error('Invalid message');
+        }
+        const guard = require('./HandlerGuard').guards.get(socket);
+        if (guard) await guard();
+        return this.onMessage(socket, message);
     }
 
     validateMessage() {