@spirobel/mininext 0.2.15 → 0.2.17

package/dist/html.d.ts

@@ -7,6 +7,7 @@ export declare class HtmlString extends Array {
     /**
      * a HtmlString is by default resolved.
      * if we we pass a function as a value to the html`` template string, it will be unresolved.
+     * it can also become unresolved if an unresolved HtmlString is passed into it as a value
      */
     resolved: boolean;
     resolve<T>(mini: Mini<T>): Promise<this>;
@@ -40,8 +41,8 @@ export declare const cssReset: HtmlString;
  * ]);
  *  ```
  */
-export declare function head(defaultHead: HtmlString): void;
-export declare function htmlResponder(mini: Mini, maybeUnresolved: HandlerReturnType, head?: HtmlString, options?: ResponseInit): Promise<Response>;
+export declare function head(defaultHead: HtmlHandler): void;
+export declare function htmlResponder(mini: Mini, maybeUnresolved: HandlerReturnType, head?: HtmlHandler, options?: ResponseInit): Promise<Response>;
 /**
  * Generic html error type guard
  * @param submissionResult output of some function

package/dist/html.js

@@ -2,19 +2,29 @@ export class HtmlString extends Array {
     /**
      * a HtmlString is by default resolved.
      * if we we pass a function as a value to the html`` template string, it will be unresolved.
+     * it can also become unresolved if an unresolved HtmlString is passed into it as a value
      */
     resolved = true;
     async resolve(mini) {
         if (this.resolved)
             return this;
         for (const [index, htmlPiece] of this.entries()) {
-            if (typeof htmlPiece === "function") {
+            if (htmlPiece instanceof HtmlString) {
+                let resolvedHtmlPiece = await htmlPiece.resolve(mini);
+                if (this instanceof JsonString || this instanceof DangerJsonInHtml) {
+                    this[index] = JSON.stringify(resolvedHtmlPiece);
+                }
+                else {
+                    this[index] = resolvedHtmlPiece;
+                }
+            }
+            else if (typeof htmlPiece === "function") {
                 let resolvedHtmlPiece = await htmlPiece(mini); //passing mini
                 if (resolvedHtmlPiece instanceof HtmlString) {
                     resolvedHtmlPiece = await resolvedHtmlPiece.resolve(mini);
                 }
                 else {
-                    if (this instanceof JsonString) {
+                    if (this instanceof JsonString || this instanceof DangerJsonInHtml) {
                         resolvedHtmlPiece = JSON.stringify(resolvedHtmlPiece);
                     }
                     else {
@@ -45,7 +55,7 @@ export function html(strings, ...values) {
         htmlStringArray.push(string);
         if (index < values.length) {
             const value = values[index];
-            // we can pass arrays of HtmlString and they will get flattened automatically
+            // we can pass arrays of HtmlString and they will get flattened in the HtmlResponder
             if (Array.isArray(value) &&
                 value.every((val) => val instanceof HtmlString)) {
                 // If the value is an array of HtmlString objects, add the whole array as a single value
@@ -76,8 +86,7 @@ export function html(strings, ...values) {
             htmlStringArray.push(values[index]);
         }
     }
-    // Flatten the HtmlString array to ensure all nested arrays are properly included
-    return htmlStringArray.flat();
+    return htmlStringArray;
 }
 export class JsonString extends HtmlString {
 }
@@ -95,7 +104,7 @@ function JsonTemplateProcessor(danger = false) {
             jsonStringArray.push(string);
             if (index < values.length) {
                 const value = values[index];
-                // we can pass arrays of HtmlString and they will get flattened automatically
+                // we can pass arrays of HtmlString and they will get flattened in the HtmlResponder
                 if (Array.isArray(value) &&
                     value.every((val) => val instanceof HtmlString)) {
                     // If the value is an array of HtmlString objects, add the whole array as a single value
@@ -106,21 +115,21 @@ function JsonTemplateProcessor(danger = false) {
                     jsonStringArray.resolved = false;
                     values[index] = value;
                 }
-                else if (!(value instanceof JsonString)) {
-                    const notEmpty = value || "";
-                    // values will be turned into a JSON string
-                    values[index] = JSON.stringify(notEmpty);
-                }
                 else if (value instanceof HtmlString) {
                     if (!value.resolved) {
                         jsonStringArray.resolved = false;
                     }
+                    values[index] = value;
+                }
+                else if (!(value instanceof JsonString)) {
+                    const notEmpty = value || "";
+                    // values will be turned into a JSON string
+                    values[index] = JSON.stringify(notEmpty);
                 }
                 jsonStringArray.push(values[index]);
             }
         }
-        // Flatten the HtmlString array to ensure all nested arrays are properly included
-        return jsonStringArray.flat();
+        return jsonStringArray;
     };
 }
 export const json = JsonTemplateProcessor();
@@ -150,7 +159,7 @@ export const cssReset = html ` <style>
     color: #fff; /* Set the default text color to white for better contrast */
   }
 </style>`;
-let default_head = html `
+let default_head = (mini) => mini.html `
   <title>mini-next</title>
   ${commonHead} ${cssReset}
 `;

package/dist/mininext.d.ts

@@ -1,9 +1,10 @@
 import { url, Mini, type HtmlHandler } from "./url";
-import { html, isError, HtmlString, head, commonHead, cssReset } from "./html";
+import { html, json, isError, HtmlString, head, commonHead, cssReset } from "./html";
 declare global {
     var PROJECT_ROOT: string | undefined;
 }
 declare function build(backendPath?: string): Promise<void>;
 declare const standardDevReloader: HtmlString;
 declare function makeEntrypoint(): Promise<(w: any) => Promise<Response>>;
-export { url, html, head, build, makeEntrypoint, isError, HtmlString, type HtmlHandler, Mini, standardDevReloader, commonHead, cssReset, };
+declare const css: typeof html;
+export { url, css, json, html, head, build, makeEntrypoint, isError, HtmlString, type HtmlHandler, Mini, standardDevReloader, commonHead, cssReset, };

package/dist/mininext.js

@@ -1,5 +1,5 @@
 import { url, Mini } from "./url";
-import { html, isError, HtmlString, head, commonHead, cssReset } from "./html";
+import { html, json, isError, HtmlString, head, commonHead, cssReset, } from "./html";
 import { watch } from "fs/promises";
 import * as path from "path";
 function projectRoot() {
@@ -158,4 +158,5 @@ async function makeEntrypoint() {
     }
     return module.default;
 }
-export { url, html, head, build, makeEntrypoint, isError, HtmlString, Mini, standardDevReloader, commonHead, cssReset, };
+const css = html;
+export { url, css, json, html, head, build, makeEntrypoint, isError, HtmlString, Mini, standardDevReloader, commonHead, cssReset, };

package/dist/url.d.ts

@@ -34,7 +34,7 @@ export declare class Mini<X = undefined> {
     dangerjson: typeof dangerjson<X>;
     data: X;
     req: Request;
-    head: (head: HtmlString) => undefined;
+    head: (head: HtmlHandler | HtmlString) => undefined;
     headers: (headers: HeadersInit, overwrite?: boolean) => undefined;
     options: (options: ResponseInit) => undefined;
     deliver: typeof url.deliver;

package/mininext/html.ts

@@ -20,18 +20,26 @@ export class HtmlString extends Array {
   /**
    * a HtmlString is by default resolved.
    * if we we pass a function as a value to the html`` template string, it will be unresolved.
+   * it can also become unresolved if an unresolved HtmlString is passed into it as a value
    */
   resolved = true;
   async resolve<T>(mini: Mini<T>) {
     if (this.resolved) return this;
 
     for (const [index, htmlPiece] of this.entries()) {
-      if (typeof htmlPiece === "function") {
+      if (htmlPiece instanceof HtmlString) {
+        let resolvedHtmlPiece = await htmlPiece.resolve(mini);
+        if (this instanceof JsonString || this instanceof DangerJsonInHtml) {
+          this[index] = JSON.stringify(resolvedHtmlPiece);
+        } else {
+          this[index] = resolvedHtmlPiece;
+        }
+      } else if (typeof htmlPiece === "function") {
         let resolvedHtmlPiece = await htmlPiece(mini); //passing mini
         if (resolvedHtmlPiece instanceof HtmlString) {
           resolvedHtmlPiece = await resolvedHtmlPiece.resolve(mini);
         } else {
-          if (this instanceof JsonString) {
+          if (this instanceof JsonString || this instanceof DangerJsonInHtml) {
             resolvedHtmlPiece = JSON.stringify(resolvedHtmlPiece);
           } else {
             const notEmpty = resolvedHtmlPiece || "";
@@ -68,7 +76,7 @@ export function html<X = undefined>(
     if (index < values.length) {
       const value = values[index];
 
-      // we can pass arrays of HtmlString and they will get flattened automatically
+      // we can pass arrays of HtmlString and they will get flattened in the HtmlResponder
       if (
         Array.isArray(value) &&
         value.every((val) => val instanceof HtmlString)
@@ -97,8 +105,7 @@ export function html<X = undefined>(
       htmlStringArray.push(values[index]);
     }
   }
-  // Flatten the HtmlString array to ensure all nested arrays are properly included
-  return htmlStringArray.flat();
+  return htmlStringArray;
 }
 export class JsonString extends HtmlString {}
 export class DangerJsonInHtml extends HtmlString {}
@@ -133,8 +140,7 @@ function JsonTemplateProcessor(danger: boolean = false) {
 
       if (index < values.length) {
         const value = values[index];
-
-        // we can pass arrays of HtmlString and they will get flattened automatically
+        // we can pass arrays of HtmlString and they will get flattened in the HtmlResponder
         if (
           Array.isArray(value) &&
           value.every((val) => val instanceof HtmlString)
@@ -145,20 +151,20 @@ function JsonTemplateProcessor(danger: boolean = false) {
         } else if (typeof value === "function") {
           jsonStringArray.resolved = false;
           values[index] = value;
-        } else if (!(value instanceof JsonString)) {
-          const notEmpty = value || "";
-          // values will be turned into a JSON string
-          values[index] = JSON.stringify(notEmpty);
         } else if (value instanceof HtmlString) {
           if (!value.resolved) {
             jsonStringArray.resolved = false;
           }
+          values[index] = value;
+        } else if (!(value instanceof JsonString)) {
+          const notEmpty = value || "";
+          // values will be turned into a JSON string
+          values[index] = JSON.stringify(notEmpty);
         }
         jsonStringArray.push(values[index]);
       }
     }
-    // Flatten the HtmlString array to ensure all nested arrays are properly included
-    return jsonStringArray.flat();
+    return jsonStringArray;
   };
 }
 export const json = JsonTemplateProcessor();
@@ -188,7 +194,7 @@ export const cssReset = html` <style>
     color: #fff; /* Set the default text color to white for better contrast */
   }
 </style>`;
-let default_head = html`
+let default_head: HtmlHandler = (mini: Mini) => mini.html`
   <title>mini-next</title>
   ${commonHead} ${cssReset}
 `;
@@ -211,14 +217,14 @@ let default_head = html`
  * ]);
  *  ```
  */
-export function head(defaultHead: HtmlString) {
+export function head(defaultHead: HtmlHandler) {
   default_head = defaultHead;
 }
 
 export async function htmlResponder(
   mini: Mini,
   maybeUnresolved: HandlerReturnType,
-  head: HtmlString = default_head,
+  head: HtmlHandler = default_head,
   options: ResponseInit = {
     headers: {
       "Content-Type": "text/html; charset=utf-8",

package/mininext/mininext.ts

@@ -1,5 +1,13 @@
 import { url, Mini, type HtmlHandler } from "./url";
-import { html, isError, HtmlString, head, commonHead, cssReset } from "./html";
+import {
+  html,
+  json,
+  isError,
+  HtmlString,
+  head,
+  commonHead,
+  cssReset,
+} from "./html";
 import { watch } from "fs/promises";
 import * as path from "path";
 function projectRoot() {
@@ -170,9 +178,11 @@ async function makeEntrypoint() {
   }
   return module.default as (w: any) => Promise<Response>;
 }
-
+const css = html;
 export {
   url,
+  css,
+  json,
   html,
   head,
   build,

package/mininext/url.ts

@@ -54,7 +54,7 @@ export class Mini<X = undefined> {
 
   data: X;
   req!: Request;
-  head!: (head: HtmlString) => undefined;
+  head!: (head: HtmlHandler | HtmlString) => undefined;
   headers!: (headers: HeadersInit, overwrite?: boolean) => undefined;
   options!: (options: ResponseInit) => undefined;
   deliver!: typeof url.deliver;
@@ -409,7 +409,7 @@ export class url {
     const handler = url.direct_handlers_html.get(reqPath);
     if (handler) {
       //this is the source of mini
-      let handlerHead: HtmlString | undefined = undefined;
+      let handlerHead: HtmlHandler | HtmlString | undefined = undefined;
       let handlerOptions: ResponseInit = {
         headers: {
           "Content-Type": "text/html; charset=utf-8",

package/package.json

@@ -11,7 +11,7 @@
 
   },
   "files": ["dist", "mininext"],
-  "version": "0.2.15",
+  "version": "0.2.17",
   "devDependencies": {
     "@types/bun": "latest"
   },