@craft-ts/component 0.7.0-beta.13 → 0.7.0-beta.16

package/src/lib/{pending-block.d.ts → pending-node.d.ts}

@@ -1,7 +1,7 @@
-import { type CraftDirective } from './types';
-import type { CraftNodeChildren } from './render/vnode';
+import { type CraftDirective } from './types.js';
+import type { CraftNodeChildren } from './render/vnode.js';
 import type { SsrMode } from '@craft-ts/core';
-export declare const PENDING_BLOCK_DIRECTIVE: unique symbol;
+export declare const PENDING_NODE_DIRECTIVE: unique symbol;
 /**
  * Where the fallback is inserted relative to the suspended subtree. The subtree
  * itself is kept mounted but **detached from the document** while it is
@@ -9,28 +9,28 @@ export declare const PENDING_BLOCK_DIRECTIVE: unique symbol;
  * CSS), so its state survives the wait. Assistive tech is told via
  * `aria-busy` / `aria-live` on the fallback, not via the detached source.
  */
-export type PendingBlockPosition = 'before' | 'after';
+export type PendingPosition = 'before' | 'after';
 export type PendingFallback = () => CraftNodeChildren;
 /**
  * What to render for one source. A bare function covers the suspended case; the
  * object form adds `reloading`, rendered **next to the still-visible subtree**
  * when the source already has a value and is refetching.
  */
-export type PendingBlockHandler = PendingFallback | {
+export type PendingHandler = PendingFallback | {
     readonly pending: PendingFallback;
     readonly reloading?: PendingFallback;
 };
 /** One handler per async source name, for the `.exhaustive` form. */
-export type PendingBlockHandlers = Readonly<Record<string, PendingBlockHandler>>;
+export type PendingHandlers = Readonly<Record<string, PendingHandler>>;
 type HandlerChildrenOf<Handler> = Handler extends () => infer Children ? Children : Handler extends {
     readonly pending: () => infer Pending;
     readonly reloading?: () => infer Reloading;
 } ? Pending | Reloading : never;
-export type PendingBlockHandlerChildren<Handler> = HandlerChildrenOf<Handler>;
+export type PendingHandlerChildren<Handler> = HandlerChildrenOf<Handler>;
 /** Resolves the children a handler renders for one of its two states. */
-export declare function resolvePendingBlockHandler(handler: PendingBlockHandler, state: 'pending' | 'reloading'): CraftNodeChildren;
+export declare function resolvePendingHandler(handler: PendingHandler, state: 'pending' | 'reloading'): CraftNodeChildren;
 /**
- * Thrown when a `CraftNotSettled` escapes every `pendingBlock` boundary — the
+ * Thrown when a `CraftNotSettled` escapes every `pendingNode` boundary — the
  * runtime counterpart of the compile-time check, for the cases the types cannot
  * see (a settled read hidden inside a lambda, a dynamically built subtree).
  */
@@ -38,30 +38,30 @@ export declare class CraftUnhandledPendingError extends Error {
     readonly source: string;
     constructor(source: string);
 }
-export type PendingBlockDirective<Handlers extends PendingBlockHandlers | undefined = undefined, FallbackChildren extends CraftNodeChildren = CraftNodeChildren> = CraftDirective & {
-    readonly [PENDING_BLOCK_DIRECTIVE]: {
+export type PendingDirective<Handlers extends PendingHandlers | undefined = undefined, FallbackChildren extends CraftNodeChildren = CraftNodeChildren> = CraftDirective & {
+    readonly [PENDING_NODE_DIRECTIVE]: {
         /** `undefined` for the catch-all form: every source below is covered. */
         readonly handlers: Handlers;
         readonly fallback: PendingFallback | undefined;
         readonly reloading: PendingFallback | undefined;
-        readonly position: PendingBlockPosition;
+        readonly position: PendingPosition;
         readonly ssr: SsrMode | undefined;
         /** Phantom carrier — the fallback's own nodes, never read at runtime. */
         readonly fallbackChildren?: FallbackChildren;
     };
 };
 /**
- * The sources a `pendingBlock` leaves uncovered. The catch-all form covers
+ * The sources a `pendingNode` leaves uncovered. The catch-all form covers
  * everything below it; the `.exhaustive` form covers only the sources it names.
  */
-export type PendingBlockResidualSources<Sources extends string, Handlers extends PendingBlockHandlers | undefined> = Handlers extends PendingBlockHandlers ? Exclude<Sources, Extract<keyof Handlers, string>> : never;
-/** Exhaustiveness check for `pendingBlock.exhaustive({...})`. */
-export type PendingBlockExhaustiveCheck<Sources extends string, Handlers extends PendingBlockHandlers> = [Exclude<Sources, Extract<keyof Handlers, string>>] extends [never] ? [Exclude<Extract<keyof Handlers, string>, Sources>] extends [never] ? unknown : {
-    'pendingBlock.exhaustive has fallbacks for sources that never suspend here': Exclude<Extract<keyof Handlers, string>, Sources>;
+export type PendingResidualSources<Sources extends string, Handlers extends PendingHandlers | undefined> = Handlers extends PendingHandlers ? Exclude<Sources, Extract<keyof Handlers, string>> : never;
+/** Exhaustiveness check for `pendingNode.exhaustive({...})`. */
+export type PendingExhaustiveCheck<Sources extends string, Handlers extends PendingHandlers> = [Exclude<Sources, Extract<keyof Handlers, string>>] extends [never] ? [Exclude<Extract<keyof Handlers, string>, Sources>] extends [never] ? unknown : {
+    'pendingNode.exhaustive has fallbacks for sources that never suspend here': Exclude<Extract<keyof Handlers, string>, Sources>;
 } : {
-    'pendingBlock.exhaustive is missing a fallback for async sources': Exclude<Sources, Extract<keyof Handlers, string>>;
+    'pendingNode.exhaustive is missing a fallback for async sources': Exclude<Sources, Extract<keyof Handlers, string>>;
 };
-type PendingBlockBaseOptions<Fallback extends PendingFallback = PendingFallback> = Readonly<{
+type PendingBaseOptions<Fallback extends PendingFallback = PendingFallback> = Readonly<{
     /**
      * Rendered next to the still-visible subtree while a source that already has
      * a value is refetching. A refetch does not suspend — the stale value stays
@@ -69,14 +69,14 @@ type PendingBlockBaseOptions<Fallback extends PendingFallback = PendingFallback>
      */
     readonly reloading?: Fallback;
     /** Where the fallback goes relative to the (hidden) subtree. Defaults to `'before'`. */
-    readonly position?: PendingBlockPosition;
+    readonly position?: PendingPosition;
 }>;
 /**
  * A client-only SSR boundary must name the shell that replaces the skipped
  * subtree. Other modes may omit it when an exhaustive handler or an outer
  * boundary owns the pending UI.
  */
-export type PendingBlockOptions<Fallback extends PendingFallback = PendingFallback> = PendingBlockBaseOptions<Fallback> & (Readonly<{
+export type PendingOptions<Fallback extends PendingFallback = PendingFallback> = PendingBaseOptions<Fallback> & (Readonly<{
     readonly ssr: 'client';
     readonly fallback: Fallback;
 }> | Readonly<{
@@ -84,14 +84,14 @@ export type PendingBlockOptions<Fallback extends PendingFallback = PendingFallba
     /** Rendered while the subtree has an async source with no value yet. */
     readonly fallback?: Fallback;
 }>);
-interface PendingBlockFactory {
+interface PendingFactory {
     /**
      * A boundary that renders `fallback` while **any** async source read below it
      * has no value yet — the template equivalent of Solid's `Suspense`.
      *
      * ```ts
      * div([span(users.settledValue)]).pipe(
-     *   pendingBlock({ fallback: () => span('Chargement…') }),
+     *   pendingNode({ fallback: () => span('Chargement…') }),
      * )
      * ```
      *
@@ -99,7 +99,7 @@ interface PendingBlockFactory {
      * CSS-hidden) so nothing below it is torn down and rebuilt when the data
      * arrives. The fallback is announced with `aria-live="polite"`.
      */
-    <Fallback extends PendingFallback>(options?: PendingBlockOptions<Fallback>): PendingBlockDirective<undefined, ReturnType<Fallback> extends CraftNodeChildren ? ReturnType<Fallback> : CraftNodeChildren>;
+    <Fallback extends PendingFallback>(options?: PendingOptions<Fallback>): PendingDirective<undefined, ReturnType<Fallback> extends CraftNodeChildren ? ReturnType<Fallback> : CraftNodeChildren>;
     /**
      * A boundary with one fallback per async source, checked exhaustively against
      * the sources actually read below it — an unlisted source is a compile error,
@@ -107,7 +107,7 @@ interface PendingBlockFactory {
      *
      * ```ts
      * div([...]).pipe(
-     *   pendingBlock.exhaustive({
+     *   pendingNode.exhaustive({
      *     users: () => SkeletonList(),
      *     orders: () => SkeletonRows(),
      *   }),
@@ -117,9 +117,8 @@ interface PendingBlockFactory {
      * When several listed sources are pending at once, the fallback of the first
      * one to suspend is rendered.
      */
-    exhaustive<const Handlers extends PendingBlockHandlers>(handlers: Handlers, options?: Omit<PendingBlockOptions, 'fallback' | 'reloading'>): PendingBlockDirective<Handlers, PendingBlockHandlerChildren<Handlers[keyof Handlers]> extends CraftNodeChildren ? PendingBlockHandlerChildren<Handlers[keyof Handlers]> : CraftNodeChildren>;
+    exhaustive<const Handlers extends PendingHandlers>(handlers: Handlers, options?: Omit<PendingOptions, 'fallback' | 'reloading'>): PendingDirective<Handlers, PendingHandlerChildren<Handlers[keyof Handlers]> extends CraftNodeChildren ? PendingHandlerChildren<Handlers[keyof Handlers]> : CraftNodeChildren>;
 }
-export declare const pendingBlock: PendingBlockFactory;
-export declare function isPendingBlockDirective(value: unknown): value is PendingBlockDirective<PendingBlockHandlers | undefined>;
+export declare const pendingNode: PendingFactory;
+export declare function isPendingDirective(value: unknown): value is PendingDirective<PendingHandlers | undefined>;
 export {};
-//# sourceMappingURL=pending-block.d.ts.map

package/src/lib/{pending-block.js → pending-node.js}

@@ -1,7 +1,7 @@
-import { CRAFT_DIRECTIVE } from './types';
-export const PENDING_BLOCK_DIRECTIVE = Symbol('craft-pending-block-directive');
+import { CRAFT_DIRECTIVE } from './types.js';
+export const PENDING_NODE_DIRECTIVE = Symbol('craft-pending-node-directive');
 /** Resolves the children a handler renders for one of its two states. */
-export function resolvePendingBlockHandler(handler, state) {
+export function resolvePendingHandler(handler, state) {
     if (typeof handler === 'function') {
         return state === 'pending' ? handler() : [];
     }
@@ -10,39 +10,38 @@ export function resolvePendingBlockHandler(handler, state) {
         : (handler.reloading?.() ?? []);
 }
 /**
- * Thrown when a `CraftNotSettled` escapes every `pendingBlock` boundary — the
+ * Thrown when a `CraftNotSettled` escapes every `pendingNode` boundary — the
  * runtime counterpart of the compile-time check, for the cases the types cannot
  * see (a settled read hidden inside a lambda, a dynamically built subtree).
  */
 export class CraftUnhandledPendingError extends Error {
     source;
     constructor(source) {
-        super(`Craft async source "${source}" suspended outside of any pendingBlock(...) boundary.`);
+        super(`Craft async source "${source}" suspended outside of any pendingNode(...) boundary.`);
         this.name = 'CraftUnhandledPendingError';
         this.source = source;
     }
 }
-function createPendingBlockDirective(handlers, fallback, reloading, position, ssr) {
+function createPendingDirective(handlers, fallback, reloading, position, ssr) {
     const directive = (() => undefined);
     Object.defineProperty(directive, CRAFT_DIRECTIVE, {
         value: {
-            name: handlers ? 'pendingBlock.exhaustive' : 'pendingBlock',
+            name: handlers ? 'pendingNode.exhaustive' : 'pendingNode',
             meta: {},
             logic: (baseLogic) => baseLogic,
             template: (baseTemplate) => baseTemplate,
         },
         enumerable: false,
     });
-    Object.defineProperty(directive, PENDING_BLOCK_DIRECTIVE, {
+    Object.defineProperty(directive, PENDING_NODE_DIRECTIVE, {
         value: { handlers, fallback, reloading, position, ssr },
         enumerable: false,
     });
     return directive;
 }
-export const pendingBlock = Object.assign((options = {}) => createPendingBlockDirective(undefined, options.fallback, options.reloading, options.position ?? 'before', options.ssr), {
-    exhaustive: (handlers, options = {}) => createPendingBlockDirective(handlers, undefined, undefined, options.position ?? 'before', options.ssr),
+export const pendingNode = Object.assign((options = {}) => createPendingDirective(undefined, options.fallback, options.reloading, options.position ?? 'before', options.ssr), {
+    exhaustive: (handlers, options = {}) => createPendingDirective(handlers, undefined, undefined, options.position ?? 'before', options.ssr),
 });
-export function isPendingBlockDirective(value) {
-    return (typeof value === 'function' && PENDING_BLOCK_DIRECTIVE in value);
+export function isPendingDirective(value) {
+    return (typeof value === 'function' && PENDING_NODE_DIRECTIVE in value);
 }
-//# sourceMappingURL=pending-block.js.map

package/src/lib/project.d.ts

@@ -1,5 +1,5 @@
-import type { CraftNodeChildren, CraftNodeChildrenDependencies, ProjectionNode } from './render/vnode';
-import { CONTENT_DECLARATION_CONTEXT, CONTENT_OUTPUT, CONTENT_RENDERABLE, CONTENT_STYLE_POLICY, type ContentOptions, type InputValue, type ProjectionUnit, type RenderableContent } from './types';
+import type { CraftNodeChildren, CraftNodeChildrenDependencies, ProjectionNode } from './render/vnode.js';
+import { CONTENT_DECLARATION_CONTEXT, CONTENT_OUTPUT, CONTENT_RENDERABLE, CONTENT_STYLE_POLICY, type ContentOptions, type InputValue, type ProjectionUnit, type RenderableContent } from './types.js';
 type ContentOutput<Value> = Value extends (...args: any[]) => infer Output ? Output : never;
 type RenderableContentOutput<Value> = ContentOutput<Value> extends CraftNodeChildren ? ContentOutput<Value> : CraftNodeChildren;
 /** Brands deferred DOM content and records the caller's style opt-in. */
@@ -16,4 +16,3 @@ export declare function renderContent<Value extends RenderableContent>(value: Va
 export declare function renderContent<Value extends ProjectionUnit<any>>(value: Value | InputValue<Value>): ProjectionNode<CraftNodeChildrenDependencies<Value>, Value>;
 export declare function renderContent<SlotName extends string, Value extends RenderableContent>(slotName: SlotName, value: Value | InputValue<Value>): ProjectionNode<CraftNodeChildrenDependencies<RenderableContentOutput<Value>>, RenderableContentOutput<Value>>;
 export {};
-//# sourceMappingURL=project.d.ts.map

package/src/lib/project.js

@@ -1,6 +1,6 @@
 import { isGeneratorFunction, isYieldableValue } from '@craft-ts/core';
-import { currentCraftRenderContext } from './render/vnode';
-import { CONTENT_DECLARATION_CONTEXT, CONTENT_OUTPUT, CONTENT_RENDERABLE, CONTENT_STYLE_POLICY, } from './types';
+import { currentCraftRenderContext } from './render/vnode.js';
+import { CONTENT_DECLARATION_CONTEXT, CONTENT_OUTPUT, CONTENT_RENDERABLE, CONTENT_STYLE_POLICY, } from './types.js';
 function contentStylePolicy(value) {
     return value[CONTENT_STYLE_POLICY] === 'allow-container-styles'
         ? 'allow-container-styles'
@@ -53,4 +53,3 @@ export function renderContent(slotNameOrValue, maybeValue) {
         declarationContext,
     };
 }
-//# sourceMappingURL=project.js.map

package/src/lib/render/hydration-metadata.d.ts

@@ -1,3 +1,2 @@
 export declare function setNodeHydrationKey(node: object, key: string): void;
 export declare function hydrationKeyOf(node: object): string | undefined;
-//# sourceMappingURL=hydration-metadata.d.ts.map

package/src/lib/render/hydration-metadata.js

@@ -5,4 +5,3 @@ export function setNodeHydrationKey(node, key) {
 export function hydrationKeyOf(node) {
     return hydrationKeys.get(node);
 }
-//# sourceMappingURL=hydration-metadata.js.map

package/src/lib/render/hydration.d.ts

@@ -21,4 +21,3 @@ export type HydrationCursor = Readonly<{
     finish(): void;
 }>;
 export declare function createHydrationCursor(host: Element, onMismatch?: (error: HydrationMismatchError) => void): HydrationCursor;
-//# sourceMappingURL=hydration.d.ts.map

package/src/lib/render/hydration.js

@@ -178,4 +178,3 @@ function isDevelopment() {
     const processRef = globalThis.process;
     return (processRef === undefined || processRef.env?.['NODE_ENV'] !== 'production');
 }
-//# sourceMappingURL=hydration.js.map

package/src/lib/render/interpreter.d.ts

@@ -1,11 +1,13 @@
 import { type CraftServiceProvider, type CraftDomAdapter, type CraftRenderIdentity } from '@craft-ts/core';
-import { Injector } from '../host-runtime';
-import { type CraftComponent } from '../types';
-import { CraftStyleRegistry } from './style-registry';
-import { type RuntimeLocatorCriteria } from '../locator';
-import { type HydrationCursor } from './hydration';
-import type { CraftSsrCoordinator } from './ssr-coordinator';
-import type { CraftServerStyleCollector } from './server-style-collector';
+import { Injector } from '../host-runtime.js';
+import { type CraftComponent } from '../types.js';
+import { CraftStyleRegistry } from './style-registry.js';
+import { type RuntimeLocatorCriteria } from '../locator.js';
+import { type HydrationCursor } from './hydration.js';
+import type { CraftSsrCoordinator } from './ssr-coordinator.js';
+import type { CraftServerStyleCollector } from './server-style-collector.js';
+/** Exporté pour la suite de non-régression sécurité. */
+export declare function ɵassertSafeStyleValue(value: unknown, resourceOrigins?: readonly string[]): void;
 export interface MountedCraftComponent<Props extends object> {
     updateProps(props: Props): void;
     destroy(): void;
@@ -29,4 +31,3 @@ export type InterpretedRenderOptions = Readonly<{
 export declare function mountInterpretedComponent<Props extends object>(component: CraftComponent<Props>, host: Element, injector: Injector | object, props: Props): MountedCraftComponent<Props>;
 export declare function mountInterpretedComponentWithOptions<Props extends object>(component: CraftComponent<Props>, host: Element, injector: Injector | object, props: Props, options: InterpretedRenderOptions): MountedCraftComponent<Props>;
 export declare function mountInterpretedComponentTemplate<Context>(component: CraftComponent<any>, host: Element, injector: Injector | object, context: Context, additionalProviders?: readonly CraftServiceProvider[]): MountedCraftTemplate<Context>;
-//# sourceMappingURL=interpreter.d.ts.map