@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/src/data/codec.ts

@@ -0,0 +1,247 @@
+import { fromJSON, toJSON } from 'seroval';
+import { validateSerializedData } from './tree';
+
+export const DATA_CODEC = 'seroval-json@1.6.8' as const;
+export const MAX_DATA_BYTES = 1024 * 1024;
+const MAX_DEPTH = 100;
+const MAX_NODES = 20_000;
+
+export class DataProtocolError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DataProtocolError';
+  }
+}
+
+/** Only explicit loader/action results are public. Request context is not data. */
+export function assertPublicData(
+  value: unknown,
+  options: { privateReferences?: WeakSet<object> } = {},
+): void {
+  const seen = new WeakSet<object>();
+  let count = 0;
+  const visit = (current: unknown, depth: number): void => {
+    if (++count > MAX_NODES || depth > MAX_DEPTH) {
+      throw new DataProtocolError(
+        'Public data exceeds its size or depth limit',
+      );
+    }
+    if (current === null || current === undefined) return;
+    const type = typeof current;
+    if (
+      (type === 'object' || type === 'function') &&
+      options.privateReferences?.has(current as object)
+    ) {
+      throw new DataProtocolError(
+        'Request-private context cannot be transferred as public data',
+      );
+    }
+    if (
+      type === 'string' ||
+      type === 'boolean' ||
+      type === 'number' ||
+      type === 'bigint'
+    )
+      return;
+    if (type !== 'object') {
+      throw new DataProtocolError(`Unsupported public data type: ${type}`);
+    }
+    const object = current as object;
+    if (seen.has(object)) return;
+    seen.add(object);
+    const prototype = Object.getPrototypeOf(object);
+    if (
+      prototype !== Object.prototype &&
+      prototype !== null &&
+      prototype !== Array.prototype &&
+      prototype !== Date.prototype &&
+      prototype !== RegExp.prototype &&
+      prototype !== Map.prototype &&
+      prototype !== Set.prototype
+    ) {
+      throw new DataProtocolError(
+        'Public data must not contain native views, request context or class instances',
+      );
+    }
+    const ownKeys = Reflect.ownKeys(object);
+    const descriptors: PropertyDescriptor[] = [];
+    let hidden: string | undefined;
+    for (const key of ownKeys) {
+      const descriptor = Object.getOwnPropertyDescriptor(object, key)!;
+      if (typeof key === 'symbol' || descriptor.get || descriptor.set) {
+        throw new DataProtocolError(
+          'Public data must not contain symbols or accessors',
+        );
+      }
+      // Serialization enumerates a plain object's own keys, so a hidden
+      // property would vanish on the client. Arrays are written by index, and
+      // native containers reject own properties below.
+      if (
+        !descriptor.enumerable &&
+        (prototype === Object.prototype || prototype === null)
+      )
+        hidden ??= key;
+      descriptors.push(descriptor);
+    }
+    if (
+      prototype === Array.prototype &&
+      ownKeys.some(
+        key =>
+          key !== 'length' &&
+          (typeof key !== 'string' ||
+            !/^(?:0|[1-9]\d*)$/.test(key) ||
+            Number(key) >= 0xffff_ffff),
+      )
+    ) {
+      throw new DataProtocolError(
+        'Public data arrays must contain only length and canonical index properties',
+      );
+    }
+    if (prototype === Array.prototype) {
+      // The serializer writes every hole of a sparse array, so holes count
+      // toward the node budget before it runs.
+      const length: unknown = Object.getOwnPropertyDescriptor(
+        object,
+        'length',
+      )?.value;
+      if (typeof length === 'number') count += length - (ownKeys.length - 1);
+      if (count > MAX_NODES)
+        throw new DataProtocolError(
+          'Public data exceeds its size or depth limit',
+        );
+    }
+    // Native serializers may read nonenumerable method overrides too. Validate
+    // every own value before using a container, without calling its properties.
+    for (const descriptor of descriptors) visit(descriptor.value, depth + 1);
+    if (hidden !== undefined)
+      throw new DataProtocolError(
+        `Public data must not contain non-enumerable properties (${hidden})`,
+      );
+    try {
+      if (prototype === Array.prototype && !Array.isArray(object)) {
+        throw new TypeError('Missing native array slots');
+      }
+      if (prototype === Date.prototype) Date.prototype.valueOf.call(object);
+      if (prototype === RegExp.prototype) {
+        Object.getOwnPropertyDescriptor(RegExp.prototype, 'source')!.get!.call(
+          object,
+        );
+      }
+      if (prototype === Map.prototype)
+        Map.prototype.has.call(object, undefined);
+      if (prototype === Set.prototype)
+        Set.prototype.has.call(object, undefined);
+    } catch {
+      throw new DataProtocolError(
+        'Public data requires valid native container values',
+      );
+    }
+    if (
+      ((prototype === Date.prototype ||
+        prototype === Map.prototype ||
+        prototype === Set.prototype) &&
+        ownKeys.length > 0) ||
+      (prototype === RegExp.prototype &&
+        ownKeys.some(key => key !== 'lastIndex'))
+    ) {
+      throw new DataProtocolError(
+        'Public data native containers must not override their built-in properties',
+      );
+    }
+    // A decoded RegExp starts at lastIndex 0, so a global or sticky RegExp
+    // advanced by exec/test would silently lose its position.
+    if (
+      prototype === RegExp.prototype &&
+      Object.getOwnPropertyDescriptor(object, 'lastIndex')?.value !== 0
+    ) {
+      throw new DataProtocolError(
+        'Public data RegExp values must have lastIndex 0',
+      );
+    }
+    if (prototype === Map.prototype) {
+      for (const [key, entry] of Map.prototype.entries.call(object)) {
+        visit(key, depth + 1);
+        visit(entry, depth + 1);
+      }
+    } else if (prototype === Set.prototype) {
+      for (const entry of Set.prototype.values.call(object)) {
+        visit(entry, depth + 1);
+      }
+    }
+  };
+  visit(value, 0);
+}
+
+/** JSON text stays inert when it is placed in a script element. */
+export function escapeInlineDataJSON(text: string): string {
+  return text.replace(/[<>&\u2028\u2029]/gu, character => {
+    switch (character) {
+      case '<':
+        return '\\u003C';
+      case '>':
+        return '\\u003E';
+      case '&':
+        return '\\u0026';
+      case '\u2028':
+        return '\\u2028';
+      default:
+        return '\\u2029';
+    }
+  });
+}
+
+/** JSON text. `serializeInlineData` escapes it when it goes into a document. */
+export function serializePublicData(value: unknown): string {
+  assertPublicData(value);
+  const text = JSON.stringify({
+    codec: DATA_CODEC,
+    data: toJSON(value, { depthLimit: MAX_DEPTH }),
+  });
+  // A document carries the escaped form, and the decoder bounds that size.
+  if (
+    new TextEncoder().encode(escapeInlineDataJSON(text)).byteLength >
+    MAX_DATA_BYTES
+  ) {
+    throw new DataProtocolError('Public data exceeds its byte limit');
+  }
+  // Apply the exact decoder limits to our wire representation before emitting it.
+  try {
+    validateSerializedData(JSON.parse(text).data);
+  } catch {
+    throw new DataProtocolError(
+      'Public data exceeds the supported codec limits',
+    );
+  }
+  return text;
+}
+
+export function parsePublicData(text: string): unknown {
+  // A document carries the escaped form, and the decoder bounds that size.
+  if (
+    new TextEncoder().encode(escapeInlineDataJSON(text)).byteLength >
+    MAX_DATA_BYTES
+  ) {
+    throw new DataProtocolError('Public data exceeds its byte limit');
+  }
+  try {
+    const envelope: unknown = JSON.parse(text);
+    if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)) {
+      throw new DataProtocolError('Malformed public data envelope');
+    }
+    const record = envelope as Record<string, unknown>;
+    if (
+      Object.keys(record).length !== 2 ||
+      record.codec !== DATA_CODEC ||
+      !Object.hasOwn(record, 'data')
+    ) {
+      throw new DataProtocolError('Unsupported public data codec');
+    }
+    validateSerializedData(record.data);
+    const result: unknown = fromJSON(record.data);
+    assertPublicData(result);
+    return result;
+  } catch (error) {
+    if (error instanceof DataProtocolError) throw error;
+    throw new DataProtocolError('Malformed public data payload');
+  }
+}

package/src/data/index.ts

@@ -0,0 +1,8 @@
+export * from './client';
+export * from './codec';
+export type { RequestDataPolicy } from './private';
+export { createRequestDataPolicy } from './private';
+export * from './routes';
+export * from './server';
+export * from './static';
+export * from './types';

package/src/data/private.ts

@@ -0,0 +1,68 @@
+import { assertPublicData, DataProtocolError } from './codec';
+
+export interface RequestDataPolicy {
+  assertRoot(value: unknown): void;
+  assertValue(value: unknown): void;
+}
+
+/** Capture aliases before callbacks, and retain them as request context changes. */
+export function createRequestDataPolicy(
+  roots: readonly unknown[],
+): RequestDataPolicy {
+  const references = new WeakSet<object>();
+  const refresh = (): void => {
+    const seen = new WeakSet<object>();
+    let count = 0;
+    const visit = (value: unknown, depth: number): void => {
+      if (
+        value === null ||
+        (typeof value !== 'object' && typeof value !== 'function')
+      )
+        return;
+      if (seen.has(value)) return;
+      if (++count > 20_000 || depth > 100) {
+        throw new DataProtocolError(
+          'Private request context exceeds its size or depth limit',
+        );
+      }
+      seen.add(value);
+      references.add(value);
+      // Context may hold opaque hosts or callables; owned data properties still
+      // carry private identities, while accessors remain completely untouched.
+      for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key)!;
+        if (!descriptor.get && !descriptor.set)
+          visit(descriptor.value, depth + 1);
+      }
+      if (value instanceof Map) {
+        for (const [key, entry] of Map.prototype.entries.call(value)) {
+          visit(key, depth + 1);
+          visit(entry, depth + 1);
+        }
+      } else if (value instanceof Set) {
+        for (const entry of Set.prototype.values.call(value))
+          visit(entry, depth + 1);
+      }
+    };
+    for (const root of roots) visit(root, 0);
+  };
+  refresh();
+  return {
+    assertRoot(value) {
+      refresh();
+      if (
+        value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        references.has(value)
+      ) {
+        throw new DataProtocolError(
+          'Request-private context cannot be transferred as public data',
+        );
+      }
+    },
+    assertValue(value) {
+      refresh();
+      assertPublicData(value, { privateReferences: references });
+    },
+  };
+}

package/src/data/routes.ts

@@ -0,0 +1,201 @@
+/** Module references remain build-time strings; adapters import their own views. */
+export interface RouteModuleReferences {
+  data?: string;
+  clientData?: string;
+  loading?: string;
+  error?: string;
+  search?: string;
+  head?: string;
+  notFound?: string;
+}
+
+/** Filesystem structure only. Matching and scheduling belong to native routers. */
+export interface FileSystemRouteIR {
+  id: string;
+  file?: string;
+  path?: string;
+  index?: boolean;
+  isRoot?: boolean;
+  modules?: RouteModuleReferences;
+  children: FileSystemRouteIR[];
+}
+
+const moduleFields = [
+  'data',
+  'clientData',
+  'loading',
+  'error',
+  'search',
+  'head',
+  'notFound',
+] as const;
+const viewFields = ['file', '_component', 'component', 'filename'] as const;
+
+function routeRecord(
+  value: unknown,
+  location: string,
+): Record<string, unknown> {
+  if (
+    value === null ||
+    typeof value !== 'object' ||
+    (Object.getPrototypeOf(value) !== Object.prototype &&
+      Object.getPrototypeOf(value) !== null)
+  ) {
+    throw new TypeError(`${location} must be a plain route object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function routeField(
+  record: Record<string, unknown>,
+  key: string,
+  location: string,
+) {
+  const descriptor = Object.getOwnPropertyDescriptor(record, key);
+  if (descriptor && !('value' in descriptor)) {
+    throw new TypeError(`${location}.${key} must be a value, not an accessor`);
+  }
+  return descriptor?.value;
+}
+
+function optionalString(
+  record: Record<string, unknown>,
+  key: string,
+  location: string,
+  allowEmpty = false,
+): string | undefined {
+  const value = routeField(record, key, location);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== 'string' || (!allowEmpty && value.trim().length === 0)) {
+    throw new TypeError(
+      `${location}.${key} must be ${allowEmpty ? 'a' : 'a non-empty'} string`,
+    );
+  }
+  return value;
+}
+
+function optionalBoolean(
+  record: Record<string, unknown>,
+  key: string,
+  location: string,
+): boolean | undefined {
+  const value = routeField(record, key, location);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== 'boolean') {
+    throw new TypeError(`${location}.${key} must be a boolean`);
+  }
+  return value;
+}
+
+/**
+ * Project the structural CLI route shape without retaining source objects,
+ * executable handlers, component values, or arbitrary configuration.
+ * Input order and conventional path syntax survive the projection unchanged.
+ */
+export function projectFileSystemRoutes(routes: unknown): FileSystemRouteIR[] {
+  if (!Array.isArray(routes)) {
+    throw new TypeError('routes must be an array');
+  }
+
+  const ids = new Set<string>();
+  const ancestors = new Set<object>();
+
+  const project = (
+    value: unknown,
+    coordinates: number[],
+  ): FileSystemRouteIR => {
+    const location = `routes[${coordinates.join('].children[')}]`;
+    if (coordinates.length > 256) {
+      throw new TypeError(`${location} exceeds the maximum route depth`);
+    }
+    const record = routeRecord(value, location);
+    if (ancestors.has(record)) {
+      throw new TypeError(`${location} contains a route cycle`);
+    }
+
+    let file: string | undefined;
+    for (const key of viewFields) {
+      // Validate every recognized reference even when an earlier one wins.
+      const reference = optionalString(record, key, location);
+      file ??= reference;
+    }
+    const id =
+      optionalString(record, 'id', location) ??
+      file ??
+      `route-${coordinates.join('.')}`;
+    if (ids.has(id)) {
+      throw new TypeError(`${location} duplicates route id "${id}"`);
+    }
+    ids.add(id);
+
+    const path = optionalString(record, 'path', location, true);
+    const index = optionalBoolean(record, 'index', location);
+    const isRoot = optionalBoolean(record, 'isRoot', location);
+    const children = routeField(record, 'children', location);
+    if (children !== undefined && !Array.isArray(children)) {
+      throw new TypeError(`${location}.children must be an array`);
+    }
+    if (
+      index === true &&
+      ((children as unknown[] | undefined)?.length || isRoot === true)
+    ) {
+      throw new TypeError(
+        `${location} index routes cannot have children or be root routes`,
+      );
+    }
+
+    const modules: RouteModuleReferences = {};
+    for (const key of moduleFields) {
+      const reference = optionalString(record, key, location);
+      if (reference !== undefined) {
+        modules[key] = reference;
+      }
+    }
+
+    ancestors.add(record);
+    const projectedChildren = ((children as unknown[] | undefined) ?? []).map(
+      (child, position) => project(child, [...coordinates, position]),
+    );
+    ancestors.delete(record);
+
+    return {
+      id,
+      ...(file === undefined ? {} : { file }),
+      ...(path === undefined ? {} : { path }),
+      ...(index === undefined ? {} : { index }),
+      ...(isRoot === undefined ? {} : { isRoot }),
+      ...(Object.keys(modules).length === 0 ? {} : { modules }),
+      children: projectedChildren,
+    };
+  };
+
+  return routes.map((route, position) => project(route, [position]));
+}
+
+/** Convert conventional parameter spelling for TanStack without matching it. */
+export function toTanstackPath(pathname: string): string {
+  if (typeof pathname !== 'string') {
+    throw new TypeError('route path must be a string');
+  }
+  return pathname
+    .split('/')
+    .map(segment => {
+      if (segment === '*') {
+        return '$';
+      }
+      if (segment.startsWith(':')) {
+        const optional = segment.endsWith('?');
+        const name = segment.slice(1, optional ? -1 : undefined);
+        if (!name || /[:?*]/.test(name)) {
+          throw new TypeError(`Invalid route parameter "${segment}"`);
+        }
+        return optional ? `{-$${name}}` : `$${name}`;
+      }
+      return segment;
+    })
+    .join('/');
+}