@hyperspan/framework 0.1.0 → 0.1.2

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "@hyperspan/framework",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Hyperspan Web Framework",
-  "type": "module",
-  "module": "src/server.ts",
+  "main": "dist/index.js",
   "public": true,
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./assets": {
+      "types": "./dist/assets.d.ts",
+      "default": "./dist/assets.js"
+    }
+  },
   "author": "Vance Lucas <vance@vancelucas.com>",
   "license": "BSD-3-Clause",
   "keywords": [
@@ -23,18 +32,22 @@
   "homepage": "https://www.hyperspan.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/vlucas/hyperspan-framework"
+    "url": "git+https://github.com/vlucas/hyperspan.git"
   },
   "bugs": {
-    "url": "https://github.com/vlucas/hyperspan-framework/issues"
+    "url": "https://github.com/vlucas/hyperspan/issues"
   },
   "scripts": {
-    "test": "bun test"
+    "build": "bun ./build.ts",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "prepack": "npm run clean && npm run build"
   },
   "devDependencies": {
     "@types/bun": "^1.1.9",
     "@types/node": "^22.5.5",
     "@types/react": "^19.1.0",
+    "bun-plugin-dts": "^0.3.0",
     "bun-types": "latest",
     "prettier": "^3.2.5"
   },
@@ -42,10 +55,10 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@hyperspan/html": "^0.1.0",
+    "@hyperspan/html": "^0.1.1",
     "@preact/compat": "^18.3.1",
     "hono": "^4.7.4",
     "isbot": "^5.1.25",
-    "valibot": "^1.0.0-rc.3"
+    "zod": "^4.0.0-beta.20250415T232143"
   }
 }

package/src/assets.ts

@@ -1,17 +1,17 @@
-import { html } from '@hyperspan/html';
-import { md5 } from './clientjs/md5';
-import { readdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import {html} from '@hyperspan/html';
+import {md5} from './clientjs/md5';
+import {readdir} from 'node:fs/promises';
+import {resolve} from 'node:path';
 
-export const IS_PROD = process.env.NODE_ENV === 'production';
+const IS_PROD = process.env.NODE_ENV === 'production';
 const PWD = import.meta.dir;
 
 /**
  * Build client JS for end users (minimal JS for Hyperspan to work)
  */
-export const clientJSFiles = new Map<string, { src: string; type?: string }>();
+export const clientJSFiles = new Map<string, {src: string; type?: string}>();
 export async function buildClientJS() {
-  const sourceFile = resolve(PWD, '../', './hyperspan/clientjs/hyperspan-client.ts');
+  const sourceFile = resolve(PWD, '../', './src/clientjs/hyperspan-client.ts');
   const output = await Bun.build({
     entrypoints: [sourceFile],
     outdir: `./public/_hs/js`,
@@ -20,7 +20,7 @@ export async function buildClientJS() {
   });
 
   const jsFile = output.outputs[0].path.split('/').reverse()[0];
-  clientJSFiles.set('_hs', { src: '/_hs/js/' + jsFile });
+  clientJSFiles.set('_hs', {src: '/_hs/js/' + jsFile});
   return jsFile;
 }
 
@@ -61,7 +61,7 @@ export async function buildClientCSS() {
 export function hyperspanStyleTags() {
   const cssFiles = Array.from(clientCSSFiles.entries());
   return html`${cssFiles.map(
-    ([key, file]) => html`<link rel="stylesheet" href="/_hs/css/${file}" />`
+    ([_, file]) => html`<link rel="stylesheet" href="/_hs/css/${file}" />`
   )}`;
 }
 
@@ -84,13 +84,13 @@ export function hyperspanScriptTags() {
       }
     </script>
     ${jsFiles.map(
-      ([key, file]) =>
-        html`<script
+    ([key, file]) =>
+      html`<script
           id="js-${key}"
           type="${file.type || 'text/javascript'}"
           src="${file.src}"
         ></script>`
-    )}
+  )}
   `;
 }
 

package/src/clientjs/hyperspan-client.ts

@@ -1,5 +1,5 @@
-import { html } from '../html';
-import { Idiomorph } from './idiomorph.esm';
+import {html} from '@hyperspan/html';
+import {Idiomorph} from './idiomorph.esm';
 
 /**
  * Used for streaming content from the server to the client.
@@ -20,7 +20,7 @@ function htmlAsyncContentObserver() {
       asyncContent.forEach((el: any) => {
         try {
           // Also observe child nodes for nested async content
-          asyncContentObserver.observe(el.content, { childList: true, subtree: true });
+          asyncContentObserver.observe(el.content, {childList: true, subtree: true});
 
           const slotId = el.id.replace('_content', '');
           const slotEl = document.getElementById(slotId);
@@ -41,7 +41,7 @@ function htmlAsyncContentObserver() {
         }
       });
     });
-    asyncContentObserver.observe(document.body, { childList: true, subtree: true });
+    asyncContentObserver.observe(document.body, {childList: true, subtree: true});
   }
 }
 htmlAsyncContentObserver();

package/src/index.ts

@@ -0,0 +1 @@
+export * from './server';

package/src/server.ts

@@ -5,82 +5,12 @@ import { isbot } from 'isbot';
 import { buildClientJS, buildClientCSS } from './assets';
 import { Hono } from 'hono';
 import { serveStatic } from 'hono/bun';
+import * as z from 'zod';
 import type { Context, Handler } from 'hono';
 
-import * as v from 'valibot';
-import type {
-  AnySchema,
-  ArraySchema,
-  BigintSchema,
-  BooleanSchema,
-  DateSchema,
-  EnumSchema,
-  GenericIssue,
-  IntersectSchema,
-  LazySchema,
-  LiteralSchema,
-  NullSchema,
-  NullableSchema,
-  NullishSchema,
-  NumberSchema,
-  ObjectSchema,
-  ObjectWithRestSchema,
-  OptionalSchema,
-  PicklistSchema,
-  PipeItem,
-  RecordSchema,
-  SchemaWithPipe,
-  StrictObjectSchema,
-  StrictTupleSchema,
-  StringSchema,
-  TupleSchema,
-  TupleWithRestSchema,
-  UndefinedSchema,
-  UnionSchema,
-  VariantSchema,
-} from 'valibot';
-
 export const IS_PROD = process.env.NODE_ENV === 'production';
-const PWD = import.meta.dir;
 const CWD = process.cwd();
 
-type NonPipeSchemas =
-  | AnySchema
-  | LiteralSchema<any, any>
-  | NullSchema<any>
-  | NumberSchema<any>
-  | BigintSchema<any>
-  | StringSchema<any>
-  | BooleanSchema<any>
-  | NullableSchema<any, any>
-  | StrictObjectSchema<any, any>
-  | ObjectSchema<any, any>
-  | ObjectWithRestSchema<any, any, any>
-  | RecordSchema<any, any, any>
-  | ArraySchema<any, any>
-  | TupleSchema<any, any>
-  | StrictTupleSchema<any, any>
-  | TupleWithRestSchema<readonly any[], any, any>
-  | IntersectSchema<any, any>
-  | UnionSchema<any, any>
-  | VariantSchema<any, any, any>
-  | PicklistSchema<any, any>
-  | EnumSchema<any, any>
-  | LazySchema<any>
-  | DateSchema<any>
-  | NullishSchema<any, any>
-  | OptionalSchema<any, any>
-  | UndefinedSchema<any>;
-
-type PipeSchema = SchemaWithPipe<[NonPipeSchemas, ...PipeItem<any, any, GenericIssue<any>>[]]>;
-// Type inference for valibot taken from:
-// @link https://github.com/gcornut/valibot-json-schema/blob/main/src/toJSONSchema/schemas.ts
-export type TSupportedSchema = NonPipeSchemas | PipeSchema;
-
-/**
- * ===========================================================================
- */
-
 /**
  * Route
  * Define a route that can handle a direct HTTP request
@@ -114,7 +44,7 @@ export function createComponent(render: () => THSComponentReturn | Promise<THSCo
  */
 export function createForm(
   renderForm: (data?: any) => THSResponseTypes,
-  schema?: TSupportedSchema | null
+  schema?: z.ZodSchema | null
 ): HSFormRoute {
   return new HSFormRoute(renderForm, schema);
 }
@@ -165,12 +95,12 @@ export class HSFormRoute {
   _handlers: Record<string, Handler> = {};
   _form: THSFormRenderer;
   _methods: null | string[] = null;
-  _schema: null | TSupportedSchema = null;
+  _schema: null | z.ZodSchema = null;
 
-  constructor(renderForm: THSFormRenderer, schema: TSupportedSchema | null = null) {
+  constructor(renderForm: THSFormRenderer, schema: z.ZodSchema | null = null) {
     // Haz schema?
     if (schema) {
-      type TSchema = v.InferInput<typeof schema>;
+      type TSchema = z.infer<typeof schema>;
       this._form = renderForm as (data: TSchema) => THSResponseTypes;
       this._schema = schema;
     } else {
@@ -178,7 +108,7 @@ export class HSFormRoute {
     }
 
     // GET request is render form by default
-    this._handlers.GET = (ctx: Context) => renderForm(this.getDefaultData());
+    this._handlers.GET = () => renderForm(this.getDefaultData());
   }
 
   // Form data
@@ -187,8 +117,8 @@ export class HSFormRoute {
       return {};
     }
 
-    type TSchema = v.InferInput<typeof this._schema>;
-    const data = v.parse(this._schema, {});
+    type TSchema = z.infer<typeof this._schema>;
+    const data = z.parse(this._schema, {});
     return data as TSchema;
   }
 
@@ -276,8 +206,15 @@ export async function runFileRoute(RouteModule: any, context: Context): Promise<
       return routeContent;
     }
 
+    let routeKind = typeof routeContent;
+
     // Render TmplHtml if returned from route handler
-    if (routeContent instanceof TmplHtml) {
+    if (
+      routeKind === 'object' &&
+      (routeContent instanceof TmplHtml ||
+        routeContent.constructor.name === 'TmplHtml' ||
+        routeContent?._kind === 'TmplHtml')
+    ) {
       if (streamingEnabled) {
         return new StreamResponse(renderStream(routeContent)) as Response;
       } else {
@@ -286,6 +223,8 @@ export async function runFileRoute(RouteModule: any, context: Context): Promise<
       }
     }
 
+    console.log('Returning unknown type... ', routeContent);
+
     return routeContent;
   } catch (e) {
     console.error(e);
@@ -379,7 +318,7 @@ export async function buildRoutes(config: THSServerConfig): Promise<THSRouteMap[
 
     if (dynamicPaths) {
       params = [];
-      route = route.replace(ROUTE_SEGMENT, (match: string, p1: string, offset: number) => {
+      route = route.replace(ROUTE_SEGMENT, (match: string) => {
         const paramName = match.replace(/[^a-zA-Z_\.]+/g, '');
 
         if (match.includes('...')) {