@adukiorg/anza 0.2.0

package/types/core/platform/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * types/core/platform/index.d.ts
+ *
+ * TypeScript declarations for browser-native feature detection flags and platform guards.
+ */
+
+export const supports: {
+  readonly navigationAPI: boolean;
+  readonly urlPattern: boolean;
+  readonly declarativeShadowDOM: boolean;
+  readonly customStatePseudo: boolean;
+  readonly formAssociated: boolean;
+  readonly popoverAPI: boolean;
+  readonly anchorPositioning: boolean;
+  readonly viewTransitions: boolean;
+  readonly scrollTimeline: boolean;
+  readonly viewTimeline: boolean;
+  readonly schedulerPostTask: boolean;
+  readonly schedulerYield: boolean;
+  readonly contentVisibility: boolean;
+  readonly cssScope: boolean;
+  readonly cssLayer: boolean;
+  readonly cssModuleScripts: boolean;
+  readonly importMaps: boolean;
+  readonly sanitizerAPI: boolean;
+  readonly trustedTypes: boolean;
+  readonly subtleCrypto: boolean;
+  readonly opfs: boolean;
+  readonly storageManager: boolean;
+  readonly fileSystemPickers: boolean;
+  readonly compression: boolean;
+  readonly storagePersistence: boolean;
+  readonly backgroundSync: boolean;
+  readonly speculationRules: boolean;
+  readonly sharedWorker: boolean;
+  readonly webLocks: boolean;
+  readonly offscreenCanvas: boolean;
+  readonly pushAPI: boolean;
+  readonly notificationsAPI: boolean;
+  readonly screenWakeLock: boolean;
+  readonly idleDetection: boolean;
+  readonly webAuthn: boolean;
+};
+
+export function reset(key: keyof typeof supports): void;
+
+export interface SanitizerWrapper {
+  sanitizeToString(input: string): string;
+}
+
+export const guard: {
+  urlPattern(): Promise<any>;
+  navigation(): Promise<any>;
+  popover(): Promise<void>;
+  shadow(root?: ParentNode): Promise<void>;
+  anchor(floating: HTMLElement, anchorEl: HTMLElement, options?: any): Promise<void>;
+  sanitizer(): Promise<SanitizerWrapper>;
+  scheduler(): Promise<any>;
+  yield(): Promise<void>;
+};

package/types/core/router/index.d.ts

@@ -0,0 +1,203 @@
+/**
+ * types/core/router/index.d.ts
+ *
+ * Strict TypeScript declarations for the Native Router runtime.
+ */
+
+import { Disposer } from '../ui/index.js';
+
+export interface RouteRecord {
+  patternStr: string;
+  handler: unknown;
+  meta: Record<string, unknown>;
+  pattern: any;
+}
+
+export interface ChainSegment {
+  route: RouteRecord;
+  tag: string;
+  params: Record<string, string>;
+}
+
+export interface MatchResult {
+  route: RouteRecord;
+  tag: string;
+  params: Record<string, string>;
+  query: Record<string, string>;
+  hash: string;
+  chain: ChainSegment[];
+  result: any;
+}
+
+export interface NavigationResult {
+  committed: Promise<any>;
+  finished: Promise<any>;
+}
+
+export interface RouterEventPayloads {
+  found: {
+    tag: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    hash: string;
+    chain: ChainSegment[];
+    url: string;
+    direction: string;
+  };
+  notfound: {
+    url: string;
+  };
+  error: {
+    error: Error;
+    url: string | null;
+    route: RouteRecord | null;
+    phase: string;
+  };
+}
+
+export type RouterGuard = (
+  destination: any,
+  controller: any
+) => string | null | undefined | Promise<string | null | undefined>;
+
+export interface GuardsApi {
+  add(guardFn: RouterGuard): Disposer;
+  clear(): void;
+}
+
+export interface MissApi {
+  set(handler: (event: any) => any): Disposer;
+  clear(): void;
+}
+
+export interface SyncApi {
+  start(r?: any): void;
+  stop(): void;
+  active(): boolean;
+  close(): void;
+}
+
+export interface LinksApi {
+  add(
+    pattern: string,
+    factory: (ctx: { url: URL; params: Record<string, string> }) => any
+  ): Disposer;
+  remove(pattern: string): void;
+  clear(): void;
+}
+
+export interface TransitionController {
+  url: string;
+  promise: Promise<any>;
+  on<K extends keyof RouterEventPayloads>(
+    event: K,
+    callback: (payload: RouterEventPayloads[K]) => void
+  ): this;
+  on(event: 'error', callback: (error: Error) => void): this;
+}
+
+export interface RouterApi {
+  register(patternStr: string, handler: unknown, meta?: Record<string, unknown>): void;
+  clear(): void;
+  guard(fn: RouterGuard): Disposer;
+  notFound(callback: (event: any) => void | Promise<void>): Disposer;
+
+  guards: GuardsApi;
+  miss: MissApi;
+  links: LinksApi;
+  sync: SyncApi;
+
+  navigate(url: string, options?: { state?: any; info?: any; history?: 'push' | 'replace' }): NavigationResult;
+  replace(url: string, options?: { state?: any; info?: any }): NavigationResult;
+  back(): NavigationResult;
+  forward(): NavigationResult;
+  go(delta: number): NavigationResult;
+  current(): any;
+  entries(): any[];
+  canBack(): boolean;
+  canForward(): boolean;
+
+  match(url: string | URL): Promise<MatchResult | null>;
+
+  on<K extends keyof RouterEventPayloads>(
+    type: K,
+    callback: (payload: RouterEventPayloads[K]) => void,
+    signal?: AbortSignal
+  ): Disposer;
+
+  nav: {
+    to(url: string, options?: { state?: any; info?: any; history?: 'push' | 'replace' }): TransitionController;
+  };
+
+  registerConnection(
+    pattern: string,
+    factory: (ctx: { url: URL; params: Record<string, string> }) => any
+  ): Disposer;
+  getActiveConnections(): Map<string, any>;
+  clearConnections(): void;
+
+  registerContainer(name: string, element: Element): void;
+  unregisterContainer(name: string): void;
+  getContainer(name: string): Element | null;
+  clearContainers(): void;
+
+  setup(): void;
+  destroy(): void;
+}
+
+export const router: RouterApi;
+
+export function navigate(url: string, options?: { state?: any; info?: any; history?: 'push' | 'replace' }): NavigationResult;
+export function replace(url: string, options?: { state?: any; info?: any }): NavigationResult;
+export function back(): NavigationResult;
+export function forward(): NavigationResult;
+export function go(delta: number): NavigationResult;
+export function current(): any;
+export function entries(): any[];
+export function canBack(): boolean;
+export function canForward(): boolean;
+
+export function register(patternStr: string, handler: unknown, meta?: Record<string, unknown>): void;
+export function match(url: string | URL): Promise<MatchResult | null>;
+export function clear(): void;
+export function getRoutes(): RouteRecord[];
+
+export function addGuard(guardFn: RouterGuard): Disposer;
+export function setNotFound(handler: (event: any) => any): Disposer;
+export function setup(): void;
+export function destroy(): void;
+export function on<K extends keyof RouterEventPayloads>(
+  type: K,
+  callback: (payload: RouterEventPayloads[K]) => void,
+  signal?: AbortSignal
+): Disposer;
+export const nav: {
+  to(url: string, options?: { state?: any; info?: any; history?: 'push' | 'replace' }): TransitionController;
+};
+
+export const guardsApi: GuardsApi;
+export const missApi: MissApi;
+
+export function setupTabSync(r?: any): void;
+export function registerConnection(
+  pattern: string,
+  factory: (ctx: { url: URL; params: Record<string, string> }) => any
+): Disposer;
+export function getActiveConnections(): Map<string, any>;
+export function clearConnections(): void;
+export const links: LinksApi;
+
+export function registerContainer(name: string, element: Element): void;
+export function unregisterContainer(name: string): void;
+export function getContainer(name: string): Element | null;
+export function clearContainers(): void;
+
+export class RouteOutlet extends HTMLElement {
+  update(detail: { chain: ChainSegment[]; query: Record<string, string>; hash: string }): Promise<void>;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'route-outlet': RouteOutlet;
+  }
+}

package/types/core/security/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * types/core/security/index.d.ts
+ *
+ * TypeScript declarations for the platform security operations layer.
+ */
+
+export function uuid(): string;
+export function hash(data: string | ArrayBuffer, algo?: string): Promise<ArrayBuffer>;
+export function generateKey(algo?: string, usages?: KeyUsage[], extractable?: boolean): Promise<CryptoKey>;
+export function deriveKey(password: string, salt: string | ArrayBuffer, iterations?: number): Promise<CryptoKey>;
+export function encrypt(key: CryptoKey, data: string | ArrayBuffer): Promise<ArrayBuffer>;
+export function decrypt(key: CryptoKey, combinedData: ArrayBuffer): Promise<ArrayBuffer>;
+export function sign(key: CryptoKey, data: string | ArrayBuffer): Promise<ArrayBuffer>;
+export function verify(key: CryptoKey, signature: ArrayBuffer, data: string | ArrayBuffer): Promise<boolean>;
+
+export function sanitize(html: string, config?: any): string;
+
+export function permission(name: PermissionName): Promise<PermissionState>;
+export function watchPermission(name: PermissionName, fn: (state: PermissionState) => void, signal?: AbortSignal): () => void;
+
+export const security: {
+  uuid: typeof uuid;
+  hash: typeof hash;
+  generateKey: typeof generateKey;
+  deriveKey: typeof deriveKey;
+  encrypt: typeof encrypt;
+  decrypt: typeof decrypt;
+  sign: typeof sign;
+  verify: typeof verify;
+  sanitize: typeof sanitize;
+  permission: typeof permission;
+  watchPermission: typeof watchPermission;
+};

package/types/core/state/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * types/core/state/index.d.ts
+ *
+ * TypeScript declarations for the reactive state management layer.
+ */
+
+export interface StoreOptions<T> {
+  deep?: boolean;
+  clone?: (state: T) => T;
+}
+
+export class ReactiveStore<T extends Record<string, any>> {
+  constructor(initialState: T, options?: StoreOptions<T>);
+  get<K extends keyof T>(key: K): T[K];
+  set<K extends keyof T>(key: K, value: T[K], source?: string): void;
+  subscribe<K extends keyof T>(
+    key: K,
+    callback: (val: T[K]) => void,
+    signal?: AbortSignal
+  ): () => void;
+  onMutation(callback: (key: string, value: any, source: string) => void): () => void;
+  batch(fn: () => void): void;
+  snapshot(): T;
+  hydrate(state: Partial<T>): void;
+  reset(initialState: T): void;
+  broadcast(channelName: string, keys?: string[]): () => void;
+  derived<V>(keys: string[] | (() => V), compute?: () => V): DerivedValue<V>;
+}
+
+export class DerivedValue<T> {
+  constructor(compute: () => T);
+  readonly value: T;
+  subscribe(callback: () => void): () => void;
+  dispose(): void;
+}
+
+export function derived<T>(compute: () => T): DerivedValue<T>;
+
+export function sync(
+  store: ReactiveStore<any>,
+  keys?: string[],
+  channelName?: string
+): () => void;
+
+export class PlatformStorage {
+  registerMigrations(migrations: Array<(db: IDBDatabase, tx: IDBTransaction) => void>): void;
+  open(): Promise<IDBDatabase>;
+  get(storeName: string, key: string): Promise<any>;
+  set(storeName: string, key: string, value: any, options?: { ttl?: number }): Promise<void>;
+  delete(storeName: string, key: string): Promise<void>;
+  query(storeName: string, queryFn?: (item: any) => boolean): Promise<any[]>;
+  estimate(): Promise<{ quota?: number; usage?: number }>;
+  persist(): Promise<boolean>;
+  isPersisted(): Promise<boolean>;
+}
+
+export const storage: PlatformStorage;
+
+export const state: {
+  create<T extends Record<string, any>>(initial: T, options?: StoreOptions<T>): ReactiveStore<T>;
+  derived: typeof derived;
+  sync: typeof sync;
+  storage: PlatformStorage;
+};
+
+export function setActiveSubscriber(subscriber: Set<any> | null): void;
+export function getActiveSubscriber(): Set<any> | null;
+

package/types/core/storage/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * types/core/storage/index.d.ts
+ *
+ * TypeScript declarations for the unified storage gateway.
+ */
+
+export interface StorageQuotaEstimate {
+  quota: number;
+  usage: number;
+  persisted: boolean;
+}
+
+export type StorageTier = 'memory' | 'idb' | 'opfs' | 'cache';
+
+export const storage: {
+  get(key: string, tier?: StorageTier): Promise<any>;
+  set(key: string, value: any, tier?: StorageTier, ttl?: number | null): Promise<void>;
+  delete(key: string, tier?: StorageTier): Promise<void>;
+  query(
+    storeName: string,
+    queryOpts?: {
+      index?: string;
+      range?: IDBKeyRange;
+      direction?: IDBCursorDirection;
+      limit?: number;
+    }
+  ): Promise<any[]>;
+  list(tier?: StorageTier): Promise<string[]>;
+  clear(tier?: 'all' | StorageTier): Promise<void>;
+  estimate(): Promise<StorageQuotaEstimate>;
+  persist(): Promise<boolean>;
+  persisted(): Promise<boolean>;
+  transaction(
+    storeNames: string | string[],
+    mode: 'readonly' | 'readwrite',
+    callback: (store: (name: string) => IDBObjectStore, tx: IDBTransaction) => any
+  ): Promise<any>;
+  onQuotaWarning(handler: (estimate: { usage: number; quota: number }) => void): () => void;
+};
+