@spirobel/mininext 0.2.14 → 0.2.16

package/README.md

@@ -20,6 +20,12 @@ quickstart:
 bun create spirobel/gucci yournewproject
 ```
 
+barebones quickstart:
+
+```bash
+bun create spirobel/aldi yournewproject
+```
+
 if you don't have bun installed, run first:
 
 ```bash

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>;

package/dist/html.js

@@ -2,17 +2,37 @@ 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 || this instanceof DangerJsonInHtml) {
+                        resolvedHtmlPiece = JSON.stringify(resolvedHtmlPiece);
+                    }
+                    else {
+                        const notEmpty = resolvedHtmlPiece || "";
+                        // values will be escaped by default
+                        resolvedHtmlPiece = Bun.escapeHTML(notEmpty + "");
+                    }
+                }
                 // Replace the function with the resolved HTML piece in place
                 this[index] = resolvedHtmlPiece;
             }
@@ -35,11 +55,12 @@ 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
                 values[index] = value;
+                htmlStringArray.resolved = false; // we could bother with .find here
             }
             else if (typeof value === "function") {
                 htmlStringArray.resolved = false;
@@ -57,11 +78,15 @@ export function html(strings, ...values) {
                 // values will be escaped by default
                 values[index] = Bun.escapeHTML(notEmpty + "");
             }
+            else if (value instanceof HtmlString) {
+                if (!value.resolved) {
+                    htmlStringArray.resolved = false;
+                }
+            }
             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 {
 }
@@ -79,16 +104,23 @@ 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
                     values[index] = value;
+                    jsonStringArray.resolved = false; // we could bother with .find here
                 }
                 else if (typeof value === "function") {
                     jsonStringArray.resolved = false;
                     values[index] = value;
                 }
+                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
@@ -97,8 +129,7 @@ function JsonTemplateProcessor(danger = false) {
                 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();

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/mininext/html.ts

@@ -20,16 +20,32 @@ 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 || this instanceof DangerJsonInHtml) {
+            resolvedHtmlPiece = JSON.stringify(resolvedHtmlPiece);
+          } else {
+            const notEmpty = resolvedHtmlPiece || "";
+            // values will be escaped by default
+            resolvedHtmlPiece = Bun.escapeHTML(notEmpty + "");
+          }
         }
         // Replace the function with the resolved HTML piece in place
         this[index] = resolvedHtmlPiece;
@@ -60,13 +76,14 @@ 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)
       ) {
         // If the value is an array of HtmlString objects, add the whole array as a single value
         values[index] = value;
+        htmlStringArray.resolved = false; // we could bother with .find here
       } else if (typeof value === "function") {
         htmlStringArray.resolved = false;
         values[index] = value;
@@ -80,12 +97,15 @@ export function html<X = undefined>(
         const notEmpty = value || "";
         // values will be escaped by default
         values[index] = Bun.escapeHTML(notEmpty + "");
+      } else if (value instanceof HtmlString) {
+        if (!value.resolved) {
+          htmlStringArray.resolved = false;
+        }
       }
       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 {}
@@ -120,17 +140,22 @@ 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)
         ) {
           // If the value is an array of HtmlString objects, add the whole array as a single value
           values[index] = value;
+          jsonStringArray.resolved = false; // we could bother with .find here
         } else if (typeof value === "function") {
           jsonStringArray.resolved = false;
           values[index] = value;
+        } 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
@@ -139,8 +164,7 @@ function JsonTemplateProcessor(danger: boolean = false) {
         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();

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/package.json

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