@adukiorg/anza 0.2.0

package/src/elements/primitives/text/index.js

@@ -0,0 +1,79 @@
+/**
+ * src/elements/primitives/text/index.js
+ *
+ * Primitive Element: <ui-text>
+ * Typography primitive dynamically rendering semantic tag configurations
+ * and binding typography design scales.
+ *
+ * Source: doc 04 — Web Components §3, doc 05 — Native UI Primitives §3
+ */
+
+import { ui } from '../../../core/ui/index.js';
+
+ui.element('ui-text', {
+  style: './style.css',
+  template: './index.html',
+  props: {
+    as: { type: String, reflect: true, default: 'span' },
+    size: { type: String, reflect: true },
+    weight: { type: String, reflect: true },
+    color: { type: String, reflect: true },
+    family: { type: String, reflect: true },
+    block: { type: Boolean, reflect: true }
+  },
+  mount({ el }) {
+    el._update();
+  },
+  update({ el }) {
+    el._update();
+  },
+  methods: {
+    _update() {
+      const asAttr = this.as || 'span';
+      const root = this.shadowRoot.querySelector('#root');
+      const size = this.size;
+      const weight = this.weight;
+      const color = this.color;
+      const family = this.family;
+
+      // Dynamic tag swapping
+      if (root.tagName.toLowerCase() !== asAttr.toLowerCase()) {
+        const nextRoot = document.createElement(asAttr);
+        nextRoot.id = 'root';
+        nextRoot.part = 'text';
+        while (root.firstChild) {
+          nextRoot.appendChild(root.firstChild);
+        }
+        root.replaceWith(nextRoot);
+      }
+
+      // Size mappings
+      if (size) {
+        this.style.setProperty('--text-size', `var(--font-size-${size})`);
+      } else {
+        this.style.removeProperty('--text-size');
+      }
+
+      // Weight mappings
+      if (weight) {
+        this.style.setProperty('--text-weight', `var(--font-weight-${weight})`);
+      } else {
+        this.style.removeProperty('--text-weight');
+      }
+
+      // Color mappings
+      if (color) {
+        this.style.setProperty('--text-color', `var(--color-content-${color})`);
+      } else {
+        this.style.removeProperty('--text-color');
+      }
+
+      // Family mappings
+      if (family) {
+        this.style.setProperty('--text-family', `var(--font-family-${family})`);
+      } else {
+        this.style.removeProperty('--text-family');
+      }
+    }
+  }
+}, import.meta.url);

package/src/elements/primitives/text/index.tags.json

@@ -0,0 +1 @@
+{"version":1,"refs":[],"ids":["root"],"classes":[],"tags":["slot","span"],"compound":[],"attrs":["id","part"],"refTypes":{}}

package/src/elements/primitives/text/style.css

@@ -0,0 +1,25 @@
+/* src/elements/primitives/text/style.css */
+
+:host {
+  display: inline;
+  /* Component Tokens — Semantic Reference Only */
+  --text-size:   var(--font-size-base);
+  --text-weight: var(--font-weight-regular);
+  --text-family: var(--font-family-sans);
+  --text-height: var(--line-height-normal);
+  --text-color:  var(--color-content-primary);
+}
+
+:host([block]) {
+  display: block;
+}
+
+#root {
+  font-size: var(--text-size);
+  font-weight: var(--text-weight);
+  font-family: var(--text-family);
+  line-height: var(--text-height);
+  color: var(--text-color);
+  margin: 0;
+  padding: 0;
+}

package/src/index.js

@@ -0,0 +1,23 @@
+/**
+ * src/index.js
+ *
+ * Root public API entry point for the "antigravity" npm package.
+ * Re-exports every core module and the elements registry.
+ *
+ * Usage (after npm install antigravity):
+ *   import { ReactiveStore } from 'antigravity/state';
+ *   import { api }           from 'antigravity/api';
+ *   import { animate }       from 'antigravity/animations';
+ */
+
+export * from './core/api/index.js';
+export * from './core/state/index.js';
+export * from './core/events/index.js';
+export * from './core/router/index.js';
+export * from './core/storage/index.js';
+export * from './core/offline/index.js';
+export * from './core/animations/index.js';
+export * from './core/workers/index.js';
+export * from './core/security/index.js';
+export * from './core/ui/index.js';
+export * from './core/platform/index.js';

package/src/styles/base.css

@@ -0,0 +1,66 @@
+/**
+ * styles/base.css
+ *
+ * Core base elements default styles in the "base" cascade layer.
+ * Sets root background, typographical scales, text selections, and focus outlines using tokens.
+ * Source: doc 3 §1.3, library2.md §Phase 1-C
+ */
+
+@layer base {
+  :root {
+    font-family: var(--font-family-sans);
+    font-size: var(--font-size-base);
+    color-scheme: light dark;
+  }
+
+  body {
+    background-color: var(--color-surface-page);
+    color: var(--color-content-primary);
+    min-height: 100vh;
+    font-weight: var(--font-weight-regular);
+    line-height: var(--line-height-normal);
+    transition: background-color 220ms var(--ease-out), color 180ms var(--ease-out);
+  }
+
+  /* Typography Defaults */
+  h1, h2, h3, h4, h5, h6 {
+    font-family: var(--font-family-sans);
+    color: var(--color-content-primary);
+    font-weight: var(--font-weight-semibold);
+    line-height: var(--line-height-tight);
+    letter-spacing: var(--letter-spacing-tight);
+  }
+
+  h1 { font-size: var(--font-size-3xl); margin-bottom: var(--space-4); }
+  h2 { font-size: var(--font-size-2xl); margin-bottom: var(--space-3); }
+  h3 { font-size: var(--font-size-xl); margin-bottom: var(--space-2); }
+  h4 { font-size: var(--font-size-lg); }
+  
+  p {
+    margin-bottom: var(--space-4);
+    color: var(--color-content-secondary);
+  }
+
+  a {
+    color: var(--color-content-link);
+    text-decoration: none;
+    transition: color var(--duration-fast) var(--ease-out);
+  }
+
+  a:hover {
+    color: var(--color-interactive-hover);
+    text-decoration: underline;
+  }
+
+  /* Selection highlight styles */
+  ::selection {
+    background-color: var(--color-interactive);
+    color: var(--color-content-inverse);
+  }
+
+  /* Custom high-contrast visual focus-ring */
+  :focus-visible {
+    outline: 2px solid var(--color-border-focus);
+    outline-offset: 2px;
+  }
+}

package/src/styles/index.css

@@ -0,0 +1,10 @@
+/**
+ * styles/index.css
+ *
+ * Master entry stylesheet for cascade layer configurations and element resets.
+ * Source: doc 3 §1.3, library2.md §Phase 1-C
+ */
+
+@import './layers.css';
+@import './reset.css';
+@import './base.css';

package/src/styles/layers.css

@@ -0,0 +1,9 @@
+/**
+ * styles/layers.css
+ *
+ * Establishes the explicit order of CSS cascade layers.
+ * Lower priority layers sit earlier in the declaration list.
+ * Source: doc 3 §1.3
+ */
+
+@layer reset, tokens, base, components, layouts, utilities, themes, overrides;

package/src/styles/reset.css

@@ -0,0 +1,66 @@
+/**
+ * styles/reset.css
+ *
+ * CSS Normalization and Reset inside the "reset" cascade layer.
+ * Strips default browser margins, sets box-sizing, and normalizes block displays.
+ * Source: doc 3 §1.3, library2.md §Phase 1-C
+ */
+
+@layer reset {
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+  }
+
+  html,
+  body {
+    height: 100%;
+    -webkit-text-size-adjust: 100%;
+  }
+
+  body {
+    line-height: 1.5;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+
+  /* Block displays for visual elements */
+  img,
+  picture,
+  video,
+  canvas,
+  svg {
+    display: block;
+    max-width: 100%;
+  }
+
+  /* Inherit form element typography */
+  input,
+  button,
+  textarea,
+  select {
+    font: inherit;
+    color: inherit;
+    background: none;
+    border: none;
+  }
+
+  button,
+  [role="button"] {
+    cursor: pointer;
+  }
+
+  /* Reset lists */
+  ol,
+  ul {
+    list-style: none;
+  }
+
+  /* Accessible media wrapper */
+  [hidden] {
+    display: none !important;
+  }
+}

package/src/sw/activate.js

@@ -0,0 +1,51 @@
+/**
+ * src/sw/activate.js
+ *
+ * Activation Lifecycle Helpers.
+ * Coordinates stale cache eviction pruning, controlled browsing context claims,
+ * and standard navigation preloads.
+ *
+ * Source: doc 13 — Offline and Background §3
+ */
+
+/**
+ * Prunes all cached storage buckets except for the active version and fallback cache.
+ */
+export async function pruneStale(currentCacheName) {
+  try {
+    const keys = await caches.keys();
+    const whitelist = new Set([currentCacheName, 'platform-offline-fallback']);
+
+    for (const key of keys) {
+      if (!whitelist.has(key)) {
+        await caches.delete(key);
+      }
+    }
+  } catch (err) {
+    console.warn('Pruning stale caches failed:', err);
+  }
+}
+
+/**
+ * Instructs the Service Worker to take immediate control of all controlled tabs.
+ */
+export async function claim() {
+  if (typeof self !== 'undefined' && self.clients?.claim) {
+    await self.clients.claim();
+  }
+}
+
+/**
+ * Enables standard native Navigation Preload.
+ */
+export async function enableNavPreload(registration) {
+  const targetReg = registration || (typeof self !== 'undefined' ? self.registration : null);
+
+  if (targetReg && targetReg.navigationPreload) {
+    try {
+      await targetReg.navigationPreload.enable();
+    } catch (err) {
+      console.warn('Failed to enable navigation preload:', err);
+    }
+  }
+}

package/src/sw/expire.js

@@ -0,0 +1,47 @@
+/**
+ * src/sw/expire.js
+ *
+ * Cache Expiration Pruner.
+ * Checks Cache API records, extracts custom x-expires-at response headers,
+ * and deletes expired cache records dynamically to conserve storage quota.
+ *
+ * Source: doc 13 — Offline and Background §3, doc 22 — Storage Architecture §2
+ */
+
+/**
+ * Iterates over a specific cache, parsing expires headers and deleting expired entries.
+ */
+export async function pruneExpired(cacheName) {
+  try {
+    const cache = await caches.open(cacheName);
+    const requests = await cache.keys();
+    const now = Date.now();
+
+    for (const request of requests) {
+      const response = await cache.match(request);
+      if (response) {
+        const expiresAtStr = response.headers.get('x-expires-at');
+        if (expiresAtStr) {
+          const expiresAt = parseInt(expiresAtStr, 10);
+          if (expiresAt && expiresAt < now) {
+            await cache.delete(request);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    console.warn(`Prune expired failed for cache "${cacheName}":`, err);
+  }
+}
+
+/**
+ * Sets up a periodic automatic pruning interval.
+ */
+export function setupAutoPrune(cacheName, intervalMs = 60000) {
+  if (typeof setInterval !== 'undefined') {
+    return setInterval(() => {
+      pruneExpired(cacheName).catch(() => {});
+    }, intervalMs);
+  }
+  return null;
+}

package/src/sw/index.js

@@ -0,0 +1,28 @@
+/**
+ * src/sw/index.js
+ *
+ * Public Service Worker entry point.
+ * Aggregates and re-exports all modular service worker strategies, URLPattern
+ * routing interceptors, TTL cache expiration pruners, install/activate lifecycle helpers,
+ * Background Sync task replay buffers, and Web Push notifications.
+ *
+ * Source: doc 13 — Offline and Background §3
+ */
+
+export {
+  CacheFirst,
+  NetworkFirst,
+  StaleRevalidate,
+  CacheThenNetwork,
+  NetworkOnly,
+  CacheOnly,
+  OfflineFallback
+} from './strategies.js';
+
+export { router, Router } from './routes.js';
+export { serializeRequest, deserializeRequest } from './queue.js';
+export { pruneExpired, setupAutoPrune } from './expire.js';
+export { precache, prefetchFallback } from './install.js';
+export { pruneStale, claim, enableNavPreload } from './activate.js';
+export { replayQueue, requeueFailed } from './sync.js';
+export { subscribe, notify } from './push.js';

package/src/sw/install.js

@@ -0,0 +1,35 @@
+/**
+ * src/sw/install.js
+ *
+ * Installation Lifecycle Helpers.
+ * Handles precaching of core application shell resources and offline fallback
+ * pages during the Service Worker installation phase.
+ *
+ * Source: doc 13 — Offline and Background §3, §4
+ */
+
+/**
+ * Pre-caches critical shell and script assets.
+ */
+export async function precache(cacheName, urls) {
+  try {
+    const cache = await caches.open(cacheName);
+    await cache.addAll(urls);
+  } catch (err) {
+    console.error(`Precache failed for cache "${cacheName}":`, err);
+    throw err;
+  }
+}
+
+/**
+ * Explicitly pre-caches the offline fallback page document.
+ */
+export async function prefetchFallback(fallbackUrl) {
+  try {
+    const cache = await caches.open('platform-offline-fallback');
+    await cache.add(fallbackUrl);
+  } catch (err) {
+    console.error(`Prefetch fallback failed for "${fallbackUrl}":`, err);
+    throw err;
+  }
+}

package/src/sw/push.js

@@ -0,0 +1,58 @@
+/**
+ * src/sw/push.js
+ *
+ * Web Push API Facade.
+ * Manages Web Push client subscriptions using standard VAPID credentials
+ * and encapsulates standard notification prompts.
+ *
+ * Source: doc 13 — Offline and Background §6
+ */
+
+/**
+ * Decodes a base64 VAPID public key into a standard Uint8Array key.
+ */
+function urlBase64ToUint8Array(base64String) {
+  const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+  const base64 = (base64String + padding)
+    .replace(/\-/g, '+')
+    .replace(/_/g, '/');
+
+  const rawData = atob(base64);
+  const outputArray = new Uint8Array(rawData.length);
+
+  for (let i = 0; i < rawData.length; ++i) {
+    outputArray[i] = rawData.charCodeAt(i);
+  }
+  return outputArray;
+}
+
+/**
+ * Registers a Web Push subscription.
+ */
+export async function subscribe(registration, vapidKey) {
+  const activeReg = registration || (typeof self !== 'undefined' ? self.registration : null);
+
+  if (!activeReg || !activeReg.pushManager) {
+    throw new Error('Web Push subscriptions are not supported in this context.');
+  }
+
+  const keyBytes = typeof vapidKey === 'string'
+    ? urlBase64ToUint8Array(vapidKey)
+    : vapidKey;
+
+  return activeReg.pushManager.subscribe({
+    userVisibleOnly: true,
+    applicationServerKey: keyBytes
+  });
+}
+
+/**
+ * Triggers a standard visual Notification popup.
+ */
+export async function notify(title, options = {}, registration) {
+  const activeReg = registration || (typeof self !== 'undefined' ? self.registration : null);
+
+  if (activeReg && activeReg.showNotification) {
+    return activeReg.showNotification(title, options);
+  }
+}

package/src/sw/queue.js

@@ -0,0 +1,60 @@
+/**
+ * src/sw/queue.js
+ *
+ * Request Serialization Utilities.
+ * Serializes standard browser Request objects into structured-cloneable,
+ * IndexedDB-friendly payloads and deserializes them back into standard Requests
+ * during background replay loops.
+ *
+ * Source: doc 13 — Offline and Background §5
+ */
+
+/**
+ * Converts a standard Request into a serializable object.
+ */
+export async function serializeRequest(request) {
+  const headers = {};
+  for (const [key, value] of request.headers.entries()) {
+    headers[key] = value;
+  }
+
+  const cloned = request.clone();
+  let body = null;
+
+  // GET and HEAD requests cannot hold bodies
+  if (request.method !== 'GET' && request.method !== 'HEAD') {
+    try {
+      body = await cloned.arrayBuffer();
+    } catch (err) {
+      console.warn('Unable to serialize request body:', err);
+    }
+  }
+
+  return {
+    url: request.url,
+    method: request.method,
+    headers,
+    body
+  };
+}
+
+/**
+ * Reconstructs a standard Request object from a serialized descriptor.
+ */
+export function deserializeRequest(serialized) {
+  const options = {
+    method: serialized.method,
+    headers: new Headers(serialized.headers)
+  };
+
+  if (serialized.body) {
+    const isJson = options.headers.get('content-type')?.includes('application/json');
+    if (isJson && typeof serialized.body === 'object' && !(serialized.body instanceof ArrayBuffer) && !(serialized.body instanceof Blob)) {
+      options.body = JSON.stringify(serialized.body);
+    } else {
+      options.body = serialized.body;
+    }
+  }
+
+  return new Request(serialized.url, options);
+}

package/src/sw/routes.js

@@ -0,0 +1,71 @@
+/**
+ * src/sw/routes.js
+ *
+ * Service Worker Pattern Router.
+ * Implements URLPattern matching, intercepting incoming SW fetch events
+ * and routing them to their declared caching strategy synchronously.
+ *
+ * Source: doc 09 — Routing §3, doc 13 — Offline and Background §3
+ */
+
+/**
+ * Normalizes an input pattern descriptor into a standard URLPattern instance.
+ */
+function normalize(pattern) {
+  if (pattern instanceof URLPattern) {
+    return pattern;
+  }
+
+  if (typeof pattern === 'string') {
+    // Explicit wildcard string maps to match-all pathnames
+    if (pattern === '*') {
+      return new URLPattern({ pathname: '*' });
+    }
+    // Simple string route compiles to a pathname match
+    return new URLPattern({ pathname: pattern });
+  }
+
+  // Object-based pattern parameters
+  return new URLPattern(pattern);
+}
+
+export class Router {
+  constructor() {
+    this.routes = [];
+  }
+
+  /**
+   * Registers a URLPattern and a matching caching strategy.
+   */
+  register(pattern, strategy) {
+    this.routes.push({
+      pattern: normalize(pattern),
+      strategy
+    });
+  }
+
+  /**
+   * Handles an incoming fetch event, matching registered patterns sequentially
+   * and intercepting matches.
+   */
+  handle(event) {
+    const { request } = event;
+
+    for (const route of this.routes) {
+      if (route.pattern.test(request.url)) {
+        // Intercept synchronously in fetch event tick
+        event.respondWith(route.strategy.handle(request));
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+/**
+ * Factory wrapper to construct a Router instance.
+ */
+export function router() {
+  return new Router();
+}