zylaris 1.0.2

package/packages/core/src/config.ts

@@ -0,0 +1,204 @@
+// Configuration types and helper for Zylaris
+
+/** Deployment target platforms */
+export type DeploymentTarget = 
+  | 'static'      // GitHub Pages, Surge.sh, etc.
+  | 'node'        // Node.js server
+  | 'vercel'      // Vercel (Serverless + Edge)
+  | 'netlify'     // Netlify (Functions + Edge)
+  | 'cloudflare'  // Cloudflare Pages/Workers
+  | 'deno'        // Deno Deploy
+  | 'bun';        // Bun runtime
+
+/** Serverless/Edge function config */
+export interface FunctionConfig {
+  /** Function name */
+  name?: string;
+  /** Route pattern */
+  route?: string;
+  /** Memory allocation (MB) */
+  memory?: number;
+  /** Timeout (seconds) */
+  timeout?: number;
+  /** Regions to deploy */
+  regions?: string[];
+  /** Edge function flag */
+  edge?: boolean;
+}
+
+/** Static generation options */
+export interface StaticOptions {
+  /** Routes to pre-render */
+  routes?: string[];
+  /** 404 page path */
+  fallback?: string;
+  /** Crawl dynamic routes */
+  crawl?: boolean;
+  /** Base path for assets */
+  base?: string;
+}
+
+/** Adapter configuration */
+export interface AdapterConfig {
+  /** Target platform */
+  target: DeploymentTarget;
+  /** Entry point */
+  entry?: string;
+  /** Output directory */
+  outDir?: string;
+  /** Static generation options */
+  static?: StaticOptions;
+  /** Serverless function config */
+  function?: FunctionConfig;
+  /** Environment variables to include */
+  env?: Record<string, string>;
+  /** Headers for HTTP responses */
+  headers?: Record<string, string>;
+  /** Redirects configuration */
+  redirects?: Array<{ from: string; to: string; status?: number }>;
+  /** Rewrites configuration */
+  rewrites?: Array<{ from: string; to: string }>;
+  /** Trailing slash handling */
+  trailingSlash?: 'always' | 'never' | 'ignore';
+  /** Clean URLs (no .html extension) */
+  cleanUrls?: boolean;
+}
+
+export interface ZylarisConfig {
+  /** Deployment target */
+  adapter?: DeploymentTarget | AdapterConfig;
+  /** Runtime environment */
+  runtime?: 'node' | 'edge' | 'deno' | 'bun';
+  /** Rendering configuration */
+  rendering?: {
+    default?: 'ssr' | 'csr' | 'ssg';
+    dynamicRoutes?: string[];
+    staticPaths?: string[];
+  };
+  /** Islands architecture */
+  islands?: {
+    mode?: 'auto' | 'manual' | 'off';
+    components?: string[];
+  };
+  /** Compiler options */
+  compiler?: {
+    target?: 'es2020' | 'es2022' | 'esnext';
+    minify?: boolean;
+    sourceMap?: boolean;
+  };
+  /** Server configuration */
+  server?: {
+    port?: number;
+    host?: string;
+  };
+  /** Styling options */
+  styling?: {
+    tailwind?: boolean;
+    cssModules?: boolean;
+  };
+  /** TypeScript options */
+  typescript?: {
+    strict?: boolean;
+  };
+  /** Build output */
+  build?: {
+    outDir?: string;
+    analyze?: boolean;
+  };
+  /** Deployment configuration */
+  deploy?: {
+    function?: FunctionConfig;
+    headers?: Record<string, string>;
+    redirects?: Array<{ from: string; to: string; status?: number }>;
+    rewrites?: Array<{ from: string; to: string }>;
+  };
+}
+
+/**
+ * Define Zylaris configuration with type checking
+ */
+export function defineConfig(config: ZylarisConfig): ZylarisConfig {
+  return config;
+}
+
+/** Preset configurations for common setups */
+export const presets = {
+  /** Static site (GitHub Pages, Netlify Static, etc.) */
+  static: defineConfig({
+    adapter: 'static',
+    rendering: { default: 'ssg' },
+    islands: { mode: 'off' },
+  }),
+
+  /** Node.js server */
+  node: defineConfig({
+    adapter: 'node',
+    runtime: 'node',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Vercel Serverless */
+  vercel: defineConfig({
+    adapter: 'vercel',
+    runtime: 'edge',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Vercel Edge */
+  vercelEdge: defineConfig({
+    adapter: {
+      target: 'vercel',
+      function: { edge: true },
+    },
+    runtime: 'edge',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Netlify Functions */
+  netlify: defineConfig({
+    adapter: 'netlify',
+    runtime: 'node',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Netlify Edge */
+  netlifyEdge: defineConfig({
+    adapter: {
+      target: 'netlify',
+      function: { edge: true },
+    },
+    runtime: 'edge',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Cloudflare Pages */
+  cloudflare: defineConfig({
+    adapter: 'cloudflare',
+    runtime: 'edge',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Deno Deploy */
+  deno: defineConfig({
+    adapter: 'deno',
+    runtime: 'deno',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+
+  /** Bun runtime */
+  bun: defineConfig({
+    adapter: 'bun',
+    runtime: 'bun',
+    rendering: { default: 'ssr' },
+    islands: { mode: 'auto' },
+  }),
+};
+
+export default defineConfig;

package/packages/core/src/hooks.ts

@@ -0,0 +1,142 @@
+// React-compatible hooks that use Zylaris signals under the hood
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { signal, computed, resource as createResource } from '@zylaris/reactivity';
+import type { Signal } from '@zylaris/reactivity';
+
+// useSignal - Bridge React state with Zylaris signals
+export function useSignal<T>(initialValue: T): Signal<T> {
+  const [sig] = useState(() => signal(initialValue));
+  return sig;
+}
+
+// useComputed - Computed signal in React component
+export function useComputed<T>(fn: () => T): T {
+  const [comp] = useState(() => computed(fn));
+  const [value, setValue] = useState(comp.peek());
+
+  useEffect(() => {
+    const unsubscribe = comp.subscribe(setValue);
+    return unsubscribe;
+  }, [comp]);
+
+  return value;
+}
+
+// useResource - Async data fetching
+export function useResource<T>(fetcher: () => Promise<T>) {
+  const [res] = useState(() => createResource(fetcher));
+  const [state, setState] = useState(res.peek());
+
+  useEffect(() => {
+    const unsubscribe = res.subscribe(setState);
+    return unsubscribe;
+  }, [res]);
+
+  return {
+    ...state,
+    refetch: res.refetch,
+    mutate: res.mutate,
+  };
+}
+
+// useStore - Subscribe to store changes
+export function useStore<T extends object>(store: T): T {
+  const [, _forceUpdate] = useState({});
+
+  useEffect(() => {
+    // In real implementation, subscribe to store changes
+    return () => {};
+  }, [store]);
+
+  return store;
+}
+
+// useIsomorphicLayoutEffect - Works on server and client
+export const useIsomorphicLayoutEffect = 
+  typeof window !== 'undefined' ? useEffect : () => {};
+
+// useEventListener - Attach event listeners
+export function useEventListener(
+  eventName: string,
+  handler: (event: Event) => void,
+  element: HTMLElement | Window = window
+) {
+  const savedHandler = useRef(handler);
+
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+
+  useEffect(() => {
+    const isSupported = element && element.addEventListener;
+    if (!isSupported) return;
+
+    const eventListener = (event: Event) => savedHandler.current(event);
+    element.addEventListener(eventName, eventListener);
+
+    return () => {
+      element.removeEventListener(eventName, eventListener);
+    };
+  }, [eventName, element]);
+}
+
+// useLocalStorage - Persist state to localStorage
+export function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void] {
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    if (typeof window === 'undefined') return initialValue;
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch {
+      return initialValue;
+    }
+  });
+
+  const setValue = useCallback((value: T) => {
+    try {
+      setStoredValue(value);
+      if (typeof window !== 'undefined') {
+        window.localStorage.setItem(key, JSON.stringify(value));
+      }
+    } catch (error) {
+      console.error('Error saving to localStorage:', error);
+    }
+  }, [key]);
+
+  return [storedValue, setValue];
+}
+
+// useDebounce - Debounce a value
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+
+  return debouncedValue;
+}
+
+// useThrottle - Throttle a function
+export function useThrottle<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  limit: number
+): T {
+  const lastRun = useRef<number>(0);
+
+  return useCallback(
+    (...args: Parameters<T>) => {
+      const now = Date.now();
+      if (now - lastRun.current >= limit) {
+        lastRun.current = now;
+        return fn(...args);
+      }
+    },
+    [fn, limit]
+  ) as T;
+}

package/packages/core/src/index.ts

@@ -0,0 +1,59 @@
+// Zylaris Core - The Universal Web Framework
+
+// Re-export reactivity system
+export {
+  signal,
+  computed,
+  resource,
+  createEffect,
+  batch,
+  createStore,
+  onMount,
+  onCleanup,
+  isStore,
+} from '@zylaris/reactivity';
+
+export type {
+  Signal,
+  Computed,
+  Resource,
+  ResourceState,
+  Store,
+} from '@zylaris/reactivity';
+
+// Export components
+export {
+  Show,
+  For,
+  Switch,
+  Match,
+  Suspense,
+  Dynamic,
+  Portal,
+  ErrorBoundary,
+  lazy,
+} from './components.js';
+
+// Export hooks
+export {
+  useSignal,
+  useComputed,
+  useResource,
+  useStore,
+  useIsomorphicLayoutEffect,
+  useEventListener,
+  useLocalStorage,
+  useDebounce,
+  useThrottle,
+} from './hooks.js';
+
+// Export JSX runtime
+export { jsx, jsxs, jsxDEV, Fragment, isSignal } from './jsx-runtime.js';
+export type { JSXElement, JSXNode } from './jsx-runtime.js';
+
+// Export config
+export { defineConfig } from './config.js';
+export type { ZylarisConfig } from './config.js';
+
+// Version
+export const version = '1.0.0';

package/packages/core/src/jsx-runtime.ts

@@ -0,0 +1,46 @@
+// JSX Runtime for Zylaris
+// Transforms JSX to DOM operations
+
+import type { Signal } from '@zylaris/reactivity';
+
+export type JSXElement = {
+  type: string | Function;
+  props: Record<string, unknown>;
+  key?: string | number;
+};
+
+export type JSXNode = JSXElement | string | number | null | undefined | Signal<unknown>;
+
+export function jsx(
+  type: string | Function,
+  props: Record<string, unknown>,
+  key?: string | number
+): JSXElement {
+  return { type, props: props || {}, key };
+}
+
+export function jsxs(
+  type: string | Function,
+  props: Record<string, unknown>,
+  key?: string | number
+): JSXElement {
+  return jsx(type, props, key);
+}
+
+export function jsxDEV(
+  type: string | Function,
+  props: Record<string, unknown>,
+  key?: string | number,
+  _isStaticChildren?: boolean,
+  _source?: object,
+  _self?: object
+): JSXElement {
+  return jsx(type, props, key);
+}
+
+export const Fragment = Symbol('zylaris.fragment');
+
+// Helper to check if value is a signal
+export function isSignal<T>(value: unknown): value is Signal<T> {
+  return typeof value === 'function' && 'set' in (value as object);
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "jsx": "react-jsx",
+    "jsxImportSource": "."
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+}

package/packages/dev-server/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@zylaris/dev-server",
+  "version": "1.0.0",
+  "description": "Development server for Zylaris",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./jit": {
+      "types": "./dist/jit-middleware.d.ts",
+      "import": "./dist/jit-middleware.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@zylaris/router": "workspace:*",
+    "@zylaris/compiler": "workspace:*",
+    "connect": "^3.7.0",
+    "http-proxy-middleware": "^2.0.6",
+    "mime-types": "^2.1.35",
+    "ws": "^8.16.0",
+    "chokidar": "^3.5.3",
+    "vite": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/connect": "^3.4.38",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "dev-server",
+    "hmr",
+    "zylaris"
+  ],
+  "license": "MIT"
+}