@webjsdev/core 0.7.11 → 0.7.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/core",
-  "version": "0.7.11",
+  "version": "0.7.12",
   "type": "module",
   "description": "webjs core runtime - html/css tags, WebComponent base, isomorphic renderers",
   "types": "./index.d.ts",
@@ -11,37 +11,55 @@
       "default": "./dist/webjs-core.js"
     },
     "./directives": {
+      "types": "./src/directives.d.ts",
       "source": "./src/directives.js",
       "default": "./dist/webjs-core-browser.js"
     },
     "./context": {
+      "types": "./src/context.d.ts",
       "source": "./src/context.js",
       "default": "./dist/webjs-core-browser.js"
     },
     "./task": {
+      "types": "./src/task.d.ts",
       "source": "./src/task.js",
       "default": "./dist/webjs-core-browser.js"
     },
     "./client-router": {
+      "types": "./src/router-client.d.ts",
       "source": "./src/router-client.js",
       "default": "./dist/webjs-core-browser.js"
     },
     "./lazy-loader": {
+      "types": "./src/lazy-loader.d.ts",
       "source": "./src/lazy-loader.js",
       "default": "./dist/webjs-core-lazy-loader.js"
     },
     "./testing": {
+      "types": "./src/testing.d.ts",
       "source": "./src/testing.js",
       "default": "./dist/webjs-core-testing.js"
     },
-    "./client": "./src/render-client.js",
-    "./server": "./src/render-server.js",
+    "./client": {
+      "types": "./src/render-client.d.ts",
+      "default": "./src/render-client.js"
+    },
+    "./server": {
+      "types": "./src/render-server.d.ts",
+      "default": "./src/render-server.js"
+    },
     "./component": {
       "types": "./src/component.d.ts",
       "default": "./src/component.js"
     },
-    "./registry": "./src/registry.js",
-    "./signals": "./src/signal.js",
+    "./registry": {
+      "types": "./src/registry.d.ts",
+      "default": "./src/registry.js"
+    },
+    "./signals": {
+      "types": "./src/signal.d.ts",
+      "default": "./src/signal.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/context.d.ts

@@ -0,0 +1,34 @@
+import type { ReactiveController, WebComponent } from './component.js';
+
+export interface Context<T = unknown> {
+  __context__: symbol;
+  name: string;
+}
+
+export function createContext<T = unknown>(name: string): Context<T>;
+
+export class ContextRequestEvent<T = unknown> extends Event {
+  context: Context<T>;
+  callback: (value: T, unsubscribe?: () => void) => void;
+  subscribe: boolean;
+  constructor(
+    context: Context<T>,
+    callback: (value: T, unsubscribe?: () => void) => void,
+    subscribe?: boolean,
+  );
+}
+
+export class ContextProvider<T = unknown> implements ReactiveController {
+  constructor(host: WebComponent, options: { context: Context<T>; initialValue?: T });
+  get value(): T;
+  setValue(newValue: T): void;
+  hostConnected(): void;
+  hostDisconnected(): void;
+}
+
+export class ContextConsumer<T = unknown> implements ReactiveController {
+  constructor(host: WebComponent, options: { context: Context<T>; subscribe?: boolean });
+  get value(): T | undefined;
+  hostConnected(): void;
+  hostDisconnected(): void;
+}

package/src/directives.d.ts

@@ -0,0 +1,98 @@
+export { repeat, isRepeat } from './repeat.js';
+
+export interface UnsafeHTMLDirective {
+  _$webjs: 'unsafe-html';
+  value: string;
+}
+
+export interface LiveDirective<T = unknown> {
+  _$webjs: 'live';
+  value: T;
+}
+
+export interface KeyedDirective<T = unknown> {
+  _$webjs: 'keyed';
+  key: unknown;
+  value: T;
+}
+
+export interface GuardDirective<T = unknown> {
+  _$webjs: 'guard';
+  deps: readonly unknown[];
+  fn: () => T;
+}
+
+export interface TemplateContentDirective {
+  _$webjs: 'template-content';
+  template: HTMLTemplateElement | { innerHTML?: string; content?: DocumentFragment };
+}
+
+export interface RefObject<T extends Element = Element> {
+  value: T | undefined;
+}
+
+export interface RefDirective<T extends Element = Element> {
+  _$webjs: 'ref';
+  target: RefObject<T> | ((el: T | undefined) => void);
+}
+
+export interface CacheDirective<T = unknown> {
+  _$webjs: 'cache';
+  value: T;
+}
+
+export interface UntilDirective {
+  _$webjs: 'until';
+  args: unknown[];
+}
+
+export interface AsyncAppendDirective<T = unknown> {
+  _$webjs: 'async-append';
+  iterable: AsyncIterable<T>;
+  mapper?: (value: T, index: number) => unknown;
+}
+
+export interface AsyncReplaceDirective<T = unknown> {
+  _$webjs: 'async-replace';
+  iterable: AsyncIterable<T>;
+  mapper?: (value: T, index: number) => unknown;
+}
+
+export interface WatchDirective<T = unknown> {
+  _$webjs: 'watch';
+  signal: { get(): T; __isSignal: true };
+}
+
+export function unsafeHTML(htmlString: string | null | undefined): UnsafeHTMLDirective;
+export function isUnsafeHTML(x: unknown): x is UnsafeHTMLDirective;
+export function live<T>(value: T): LiveDirective<T>;
+export function isLive(x: unknown): x is LiveDirective;
+export function keyed<T>(key: unknown, template: T): KeyedDirective<T>;
+export function isKeyed(x: unknown): x is KeyedDirective;
+export function guard<T>(deps: readonly unknown[], fn: () => T): GuardDirective<T>;
+export function isGuard(x: unknown): x is GuardDirective;
+export function templateContent(
+  template: HTMLTemplateElement | { innerHTML?: string; content?: DocumentFragment },
+): TemplateContentDirective;
+export function isTemplateContent(x: unknown): x is TemplateContentDirective;
+export function ref<T extends Element = Element>(
+  refOrCallback: RefObject<T> | ((el: T | undefined) => void),
+): RefDirective<T>;
+export function isRef(x: unknown): x is RefDirective;
+export function createRef<T extends Element = Element>(): RefObject<T>;
+export function cache<T>(value: T): CacheDirective<T>;
+export function isCache(x: unknown): x is CacheDirective;
+export function until(...args: unknown[]): UntilDirective;
+export function isUntil(x: unknown): x is UntilDirective;
+export function asyncAppend<T>(
+  iterable: AsyncIterable<T>,
+  mapper?: (value: T, index: number) => unknown,
+): AsyncAppendDirective<T>;
+export function isAsyncAppend(x: unknown): x is AsyncAppendDirective;
+export function asyncReplace<T>(
+  iterable: AsyncIterable<T>,
+  mapper?: (value: T, index: number) => unknown,
+): AsyncReplaceDirective<T>;
+export function isAsyncReplace(x: unknown): x is AsyncReplaceDirective;
+export function watch<T>(sig: { get(): T; __isSignal: true }): WatchDirective<T>;
+export function isWatch(x: unknown): x is WatchDirective;

package/src/lazy-loader.d.ts

@@ -0,0 +1,2 @@
+export function observeLazy(entries: Record<string, string>): void;
+export function observeViewportOnce(el: Element, callback: () => void): () => void;

package/src/nav.d.ts

@@ -0,0 +1,4 @@
+export function notFound(): never;
+export function redirect(url: string, status?: number): never;
+export function isNotFound(e: unknown): boolean;
+export function isRedirect(e: unknown): boolean;

package/src/registry.d.ts

@@ -0,0 +1,11 @@
+import type { WebComponent } from './component.js';
+
+export type WebComponentConstructor = typeof WebComponent;
+
+export function register(tag: string, cls: WebComponentConstructor): void;
+export function primeModuleUrl(tag: string, moduleUrl: string): void;
+export function lookup(tag: string): WebComponentConstructor | undefined;
+export function lookupModuleUrl(tag: string): string | undefined;
+export function isLazy(tag: string): boolean;
+export function tagOf(cls: WebComponentConstructor): string | undefined;
+export function allTags(): string[];

package/src/render-client.d.ts

@@ -0,0 +1 @@
+export function render(value: unknown, container: Element | DocumentFragment | ShadowRoot): void;

package/src/render-server.d.ts

@@ -0,0 +1,14 @@
+export interface SuspenseContext {
+  pending: { id: string; promise: Promise<unknown> }[];
+  nextId: number;
+}
+
+export function renderToString(
+  value: unknown,
+  opts?: { ssr?: boolean; suspenseCtx?: SuspenseContext },
+): Promise<string>;
+
+export function renderToStream(
+  value: unknown,
+  opts?: { ssr?: boolean; suspenseCtx?: SuspenseContext },
+): ReadableStream;

package/src/router-client.d.ts

@@ -0,0 +1,10 @@
+import type { Route } from './routes.js';
+
+export function enableClientRouter(): void;
+export function disableClientRouter(): void;
+export function navigate(url: Route, opts?: { replace?: boolean }): Promise<void>;
+export function loadFrame(
+  frameEl: Element,
+  url: string,
+): Promise<{ ok: boolean; status: number | null; aborted: boolean }>;
+export function revalidate(url?: string): void;

package/src/signal.d.ts

@@ -0,0 +1,21 @@
+export interface SignalState<T = unknown> {
+  readonly __isSignal: true;
+  get(): T;
+  set(value: T): void;
+}
+
+export interface SignalComputed<T = unknown> {
+  readonly __isSignal: true;
+  get(): T;
+}
+
+export function batch<T>(fn: () => T): T;
+export function signal<T>(initial: T, options?: Record<string, unknown>): SignalState<T>;
+export function computed<T>(fn: () => T, options?: Record<string, unknown>): SignalComputed<T>;
+export function isSignal(v: unknown): v is SignalState | SignalComputed;
+export function effect(fn: () => void): () => void;
+
+export const Signal: {
+  State: new <T>(initial: T, options?: Record<string, unknown>) => SignalState<T>;
+  Computed: new <T>(fn: () => T, options?: Record<string, unknown>) => SignalComputed<T>;
+};

package/src/task.d.ts

@@ -0,0 +1,33 @@
+import type { ReactiveController, WebComponent } from './component.js';
+
+export const TaskStatus: {
+  readonly INITIAL: 0;
+  readonly PENDING: 1;
+  readonly COMPLETE: 2;
+  readonly ERROR: 3;
+};
+
+export type TaskStatusValue = (typeof TaskStatus)[keyof typeof TaskStatus];
+
+export class Task<T = unknown> implements ReactiveController {
+  constructor(host: WebComponent, options: {
+    task: (...args: any[]) => Promise<T>;
+    args?: () => unknown[];
+    autoRun?: boolean;
+  });
+  get status(): TaskStatusValue;
+  get value(): T | undefined;
+  get error(): unknown;
+  run(): Promise<void>;
+  abort(): void;
+  render(handlers?: {
+    initial?: () => unknown;
+    pending?: () => unknown;
+    complete?: (value: T) => unknown;
+    error?: (error: unknown) => unknown;
+  }): unknown;
+  hostUpdate(): void;
+  hostUpdated(): void;
+  hostConnected(): void;
+  hostDisconnected(): void;
+}

package/src/testing.d.ts

@@ -0,0 +1,9 @@
+import type { TemplateResult } from './html.js';
+
+export function fixture(template: TemplateResult | string): Promise<Element>;
+export function ssrFixture(template: TemplateResult | string): Promise<Element>;
+export function waitForUpdate(el: Element): Promise<void>;
+export function assertNoA11yViolations(el: Element, opts?: Record<string, unknown>): Promise<void>;
+export function click(el: Element): void;
+export function shadowQuery(el: Element, selector: string): Element | null;
+export function shadowQueryAll(el: Element, selector: string): Element[];