@webjsdev/core 0.7.30 → 0.7.32

package/index-browser.js

@@ -28,7 +28,7 @@ export { WebComponent, prop } from './src/component.js';
 export { register, lookup, lookupModuleUrl, isLazy, allTags, primeModuleUrl, tagOf } from './src/registry.js';
 export { render } from './src/render-client.js';
 export { escapeText, escapeAttr } from './src/escape.js';
-export { notFound, redirect, isNotFound, isRedirect } from './src/nav.js';
+export { notFound, redirect, forbidden, unauthorized, isNotFound, isRedirect, isForbidden, isUnauthorized } from './src/nav.js';
 export { cspNonce } from './src/csp-nonce.js';
 export { repeat, isRepeat } from './src/repeat.js';
 export { Suspense, isSuspense } from './src/suspense.js';

package/index.d.ts

@@ -74,7 +74,7 @@ export { register, lookup, lookupModuleUrl, isLazy, allTags, primeModuleUrl, tag
 export { renderToString, renderToStream } from './src/render-server.js';
 export { render } from './src/render-client.js';
 export { escapeText, escapeAttr } from './src/escape.js';
-export { notFound, redirect, isNotFound, isRedirect } from './src/nav.js';
+export { notFound, redirect, forbidden, unauthorized, isNotFound, isRedirect, isForbidden, isUnauthorized } from './src/nav.js';
 export { repeat, isRepeat } from './src/repeat.js';
 export { Suspense, isSuspense } from './src/suspense.js';
 export { connectWS } from './src/websocket-client.js';

package/index.js

@@ -13,7 +13,7 @@ export { register, lookup, lookupModuleUrl, isLazy, allTags, primeModuleUrl, tag
 export { renderToString, renderToStream } from './src/render-server.js';
 export { render } from './src/render-client.js';
 export { escapeText, escapeAttr } from './src/escape.js';
-export { notFound, redirect, isNotFound, isRedirect } from './src/nav.js';
+export { notFound, redirect, forbidden, unauthorized, isNotFound, isRedirect, isForbidden, isUnauthorized } from './src/nav.js';
 export { cspNonce, setCspNonceProvider } from './src/csp-nonce.js';
 export { repeat, isRepeat } from './src/repeat.js';
 export { Suspense, isSuspense } from './src/suspense.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/core",
-  "version": "0.7.30",
+  "version": "0.7.32",
   "type": "module",
   "description": "webjs core runtime - html/css tags, WebComponent base, isomorphic renderers",
   "types": "./index.d.ts",

package/src/nav.d.ts

@@ -1,4 +1,8 @@
 export function notFound(): never;
 export function redirect(url: string, status?: number | { status?: number }): never;
+export function forbidden(): never;
+export function unauthorized(): never;
 export function isNotFound(e: unknown): boolean;
 export function isRedirect(e: unknown): boolean;
+export function isForbidden(e: unknown): boolean;
+export function isUnauthorized(e: unknown): boolean;

package/src/nav.js

@@ -13,6 +13,8 @@
 
 const NOT_FOUND = Symbol.for('webjs.notFound');
 const REDIRECT = Symbol.for('webjs.redirect');
+const FORBIDDEN = Symbol.for('webjs.forbidden');
+const UNAUTHORIZED = Symbol.for('webjs.unauthorized');
 
 /** @returns {never} */
 export function notFound() {
@@ -21,6 +23,35 @@ export function notFound() {
   throw err;
 }
 
+/**
+ * Throw a 403 Forbidden sentinel the SSR pipeline catches (#848, Next 15/16
+ * parity). Renders the nearest `forbidden.{js,ts}` boundary at status 403, or a
+ * default 403 page when none exists. Use for an authenticated user who lacks
+ * permission (contrast `unauthorized()` for a not-logged-in user).
+ *
+ * @returns {never}
+ */
+export function forbidden() {
+  const err = new Error('webjs: forbidden()');
+  /** @type any */ (err).__webjs = FORBIDDEN;
+  throw err;
+}
+
+/**
+ * Throw a 401 Unauthorized sentinel the SSR pipeline catches (#848, Next 15/16
+ * parity). Renders the nearest `unauthorized.{js,ts}` boundary at status 401, or
+ * a default 401 page when none exists. Use for a request that is not
+ * authenticated (contrast `forbidden()` for an authenticated-but-not-allowed
+ * user).
+ *
+ * @returns {never}
+ */
+export function unauthorized() {
+  const err = new Error('webjs: unauthorized()');
+  /** @type any */ (err).__webjs = UNAUTHORIZED;
+  throw err;
+}
+
 /**
  * Throw a redirect sentinel the SSR pipeline catches and turns into a 3xx.
  *
@@ -62,3 +93,13 @@ export function isNotFound(e) {
 export function isRedirect(e) {
   return !!e && /** @type any */ (e).__webjs === REDIRECT;
 }
+
+/** @param {unknown} e */
+export function isForbidden(e) {
+  return !!e && /** @type any */ (e).__webjs === FORBIDDEN;
+}
+
+/** @param {unknown} e */
+export function isUnauthorized(e) {
+  return !!e && /** @type any */ (e).__webjs === UNAUTHORIZED;
+}

package/src/render-client.js

@@ -264,6 +264,15 @@ function compile(tr) {
                 statics,
                 group,
               };
+              // The mixed attribute is rebuilt from ALL its holes' values, but
+              // it is anchored at a single part (group[0]). The later holes stay
+              // `noop`, so a change confined to one of them would be skipped by
+              // updateInstance's per-hole dirty-check and the attribute would go
+              // stale. Point every non-anchor member back at the anchor so a
+              // change to any hole re-applies the whole attribute.
+              for (let m = 1; m < group.length; m++) {
+                parts[group[m]] = { kind: 'noop', path: [], mixedAnchor: idx0 };
+              }
               mixedAttr = null;
             }
             state = 'in-tag';
@@ -488,7 +497,7 @@ function createInstance(tr, container) {
  * @returns {BoundPart}
  */
 function bindPart(p, root) {
-  if (p.kind === 'noop') return /** @type any */ ({ kind: 'noop' });
+  if (p.kind === 'noop') return /** @type any */ ({ kind: 'noop', mixedAnchor: /** @type any */ (p).mixedAnchor });
   let node = /** @type Node */ (root);
   for (const i of p.path) node = node.childNodes[i];
   if (p.kind === 'child') {
@@ -533,7 +542,18 @@ function updateInstance(inst, values) {
   for (let i = 0; i < values.length; i++) {
     const next = values[i];
     if (Object.is(next, inst.lastValues[i])) continue;
-    applyPart(inst.bound[i], next, inst.lastValues[i], values);
+    const bp = inst.bound[i];
+    // A hole that belongs to a mixed attribute (`class="a ${x} b ${y}"`) is a
+    // `noop` pointing at the attribute's anchor part; re-apply the anchor so the
+    // whole attribute is rebuilt from every hole's current value, not just the
+    // anchor hole's. Without this, a change confined to a non-anchor hole is
+    // dropped (the attribute goes stale).
+    const anchor = /** @type any */ (bp).mixedAnchor;
+    if (bp.kind === 'noop' && anchor != null) {
+      applyPart(inst.bound[anchor], values[anchor], inst.lastValues[anchor], values);
+    } else {
+      applyPart(bp, next, inst.lastValues[i], values);
+    }
     inst.lastValues[i] = next;
   }
 }

package/src/routes.d.ts

@@ -84,6 +84,14 @@ export type RouteParams<R extends string> = R extends keyof RouteParamMap
   ? RouteParamMap[R]
   : Record<string, string>;
 
+/**
+ * A value that is BOTH synchronously usable as `T` and `await`-able to `T`
+ * (#848). The webjs runtime hands `params` / `searchParams` as a plain object
+ * carrying a non-enumerable `then`, so `params.id` and `await params` both
+ * work; this type expresses that dual nature to TypeScript.
+ */
+export type Awaitable<T> = T & PromiseLike<T>;
+
 /**
  * The argument a page default-export receives. Mirrors the `ctx` object
  * packages/server/src/ssr.js builds: `{ params, searchParams, url,
@@ -94,16 +102,22 @@ export type RouteParams<R extends string> = R extends keyof RouteParamMap
  * `Object.fromEntries(url.searchParams.entries())` (so a repeated key is
  * last-wins `string`, never an array). The wider type keeps a future
  * multi-value reader source-compatible.
+ *
+ * `params` / `searchParams` are `Awaitable<T>` (#848): synchronously readable
+ * (`params.id`) AND `await`-able (`const { id } = await params`) for Next
+ * 15/16 muscle-memory parity. The runtime object carries a non-enumerable
+ * `then` (see packages/server/src/thenable-params.js), so a spread / JSON /
+ * `Object.keys` sees only the data keys.
  */
 export interface PageProps<R extends string = string> {
   /**
    * Path params. A generated dynamic route narrows this to its exact shape
    * (`{ slug: string }`); a static or un-generated route is
-   * `Record<string, string>`.
+   * `Record<string, string>`. Sync-readable and `await`-able (#848).
    */
-  params: R extends keyof RouteParamMap ? RouteParamMap[R] : Record<string, string>;
-  /** Query string, as an object. Repeated keys are last-wins at runtime. */
-  searchParams: Record<string, string | string[]>;
+  params: Awaitable<R extends keyof RouteParamMap ? RouteParamMap[R] : Record<string, string>>;
+  /** Query string, as an object. Repeated keys are last-wins at runtime. Sync-readable and `await`-able (#848). */
+  searchParams: Awaitable<Record<string, string | string[]>>;
   /** The full request URL string. */
   url: string;
   /**
@@ -132,5 +146,6 @@ export interface LayoutProps<R extends string = string> extends PageProps<R> {
  * narrow them against a generated route the same way `PageProps` does.
  */
 export interface RouteHandlerContext<R extends string = string> {
-  params: R extends keyof RouteParamMap ? RouteParamMap[R] : Record<string, string>;
+  /** Sync-readable and `await`-able (#848), same as `PageProps['params']`. */
+  params: Awaitable<R extends keyof RouteParamMap ? RouteParamMap[R] : Record<string, string>>;
 }