@spirobel/mininext 0.5.1 → 0.6.1

package/dist/mininext.d.ts

@@ -2,11 +2,11 @@
 /// <reference types="bun-types" />
 import { url, Mini, has, type HtmlHandler } from "./url";
 import { isError, HtmlString, BasedHtml, head, commonHead, cssReset, basedHtml as html } from "./html";
-import type { Server, WebSocketHandler } from "bun";
+import { type Server, type WebSocketHandler } from "bun";
 declare global {
     var PROJECT_ROOT: string | undefined;
 }
-declare function build(backendPath?: string): Promise<void>;
+declare function build(backendPath?: string): Promise<0 | undefined>;
 declare const standardDevReloader: BasedHtml;
 declare function makeEntrypoint(): Promise<{
     fetch: (req: Request, server: Server) => Promise<Response>;

package/dist/mininext.js

@@ -1,11 +1,17 @@
 import { url, Mini, has } from "./url";
 import { isError, HtmlString, BasedHtml, head, commonHead, cssReset, basedHtml as html, } from "./html";
+import { $ } from "bun";
 import { watch } from "fs/promises";
 import * as path from "path";
 function projectRoot() {
     return global.PROJECT_ROOT || import.meta.dir + "/../../../../";
 }
 async function build(backendPath = "backend/backend.ts") {
+    if (Bun.argv[2] === "frontend") {
+        const newFrontend = await buildFrontend(Bun.argv[3]);
+        process.stdout.write(JSON.stringify(newFrontend));
+        return 0;
+    }
     await buildBackend(backendPath);
     if (Bun.argv[2] === "dev") {
         await devServer();
@@ -70,18 +76,29 @@ async function buildBackend(backendPath = "backend/backend.ts") {
         const frontEndPath = (await Bun.file(firstPlaceToLook).exists())
             ? firstPlaceToLook
             : secondPlaceToLook;
-        const f = await buildFrontend(frontEndPath);
-        FrontendScriptUrls.push("/" + f.url);
-        FrontendScripts.push(f.script);
+        try {
+            const f = await $ `bun run build.ts frontend ${frontEndPath}`.json();
+            FrontendScriptUrls.push("/" + f.url);
+            FrontendScripts.push(f.script);
+        }
+        catch (error) {
+            console.log(await $ `bun run build.ts frontend ${frontEndPath}`.text());
+        }
     }
-    for (const svgPath of url.getSvgPaths()) {
-        const parsedSvgPath = path.parse(svgPath);
-        const svgContent = Bun.file(path.join(projectRoot() + "/backend/", svgPath));
+    for (const svg of url.getSvgs()) {
+        const firstPlaceToLook = path.resolve(path.dirname(svg.callerPath), `svgs/${svg.svgFilePath}`);
+        const secondPlaceToLook = path.resolve(projectRoot(), `${svg.svgFilePath}`);
+        const svgResolvedFilePath = (await Bun.file(firstPlaceToLook).exists())
+            ? firstPlaceToLook
+            : secondPlaceToLook;
+        const parsedSvgPath = path.parse(svgResolvedFilePath);
+        const svgContent = Bun.file(svgResolvedFilePath);
         const svgHash = Bun.hash(await svgContent.arrayBuffer());
         const svgUrl = `/${parsedSvgPath.name}-${svgHash}.svg`;
         bundledSVGs[svgUrl] = {
             svgContent: await svgContent.text(),
-            svgPath,
+            svgFilePath: svg.svgFilePath,
+            options: svg.options,
         };
     }
     const res = await Bun.build({

package/dist/url.d.ts

@@ -78,7 +78,8 @@ declare global {
     var FrontendScriptUrls: Array<string>;
     var bundledSVGs: Record<string, {
         svgContent: string;
-        svgPath: string;
+        svgFilePath: string;
+        options: ResponseInit;
     }>;
 }
 export type ScriptTag = (...params: any[]) => Promise<HtmlString>;
@@ -91,7 +92,20 @@ export declare class url {
     static direct_handlers_html: Map<string, HtmlHandler>;
     private static frontends;
     private static svgs;
-    static svg(path: string, options?: ResponseInit): string | undefined;
+    /**
+     * This function takes care of bundling your svg (icons?) into the webapp
+     * they will have a hash in the name to break the cache when needed
+     * @param svgFilePath first place to look: svgs folder in the same path the calling file, after that path from project root.
+     * @param options ResponseInit, default headers for an svg
+     * @returns url to the svg
+     */
+    static svg(svgFilePath: string, options?: ResponseInit): string | undefined;
+    /**
+     * this function helps you build frontends with any kind of framework (no framework at all) and get the bundle
+     * @param path first place to look: frontend folder in the same path the calling file, after that /frontend path from project root.
+     * @param snippet this is handy to pass in a piece of html that often goes along with a certain frontend
+     * @returns a html script element with the bundled frontend as the src
+     */
     static frontend<X>(path: string, snippet?: BasedHtml): HtmlString;
     static frontend<X>(path: string, snippet?: HtmlHandler<X>): (mini: Mini<X>) => HtmlString;
     /**
@@ -101,7 +115,11 @@ export declare class url {
         path: string;
         callerPath: string;
     }[];
-    static getSvgPaths(): string[];
+    static getSvgs(): {
+        svgFilePath: string;
+        callerPath: string;
+        options: ResponseInit;
+    }[];
     static serveFrontend(req: Request): Response | undefined;
     static serveSvg(req: Request): Response | undefined;
     /**

package/dist/url.js

@@ -71,16 +71,28 @@ export class url {
     static direct_handlers_html = new Map();
     // An array of the uncompiled frontend files, example frontends[0] = "index.tsx" -> frontend/index.tsx (from the project root)
     static frontends = [];
-    static svgs = new Map();
-    static svg(path, options = {
+    static svgs = [];
+    /**
+     * This function takes care of bundling your svg (icons?) into the webapp
+     * they will have a hash in the name to break the cache when needed
+     * @param svgFilePath first place to look: svgs folder in the same path the calling file, after that path from project root.
+     * @param options ResponseInit, default headers for an svg
+     * @returns url to the svg
+     */
+    static svg(svgFilePath, options = {
         headers: {
             "Content-Type": "image/svg+xml",
             "Content-Disposition": "attachment",
         },
     }) {
-        url.svgs.set(path, options);
-        var foundEntry = Object.entries(bundledSVGs).find(([key, value]) => value.svgPath === path);
-        return foundEntry && foundEntry[0];
+        const stack = new Error().stack?.split("\n");
+        let callerPath = "";
+        if (stack) {
+            callerPath = stack[2].slice(stack[2].lastIndexOf("(") + 1, stack[2].lastIndexOf(".") + 3);
+        }
+        url.svgs.push({ svgFilePath, callerPath, options });
+        var foundSvg = Object.entries(bundledSVGs).find(([key, value]) => value.svgFilePath === svgFilePath);
+        return foundSvg && foundSvg[0];
     }
     static frontend(path, snippet) {
         const stack = new Error().stack?.split("\n");
@@ -105,8 +117,8 @@ export class url {
     static getFrontends() {
         return url.frontends;
     }
-    static getSvgPaths() {
-        return [...url.svgs.keys()];
+    static getSvgs() {
+        return url.svgs;
     }
     static serveFrontend(req) {
         const reqPath = new URL(req.url).pathname;
@@ -123,7 +135,7 @@ export class url {
         const reqPath = new URL(req.url).pathname;
         const resolvedSvg = bundledSVGs[reqPath];
         if (resolvedSvg) {
-            return new Response(resolvedSvg.svgContent, url.svgs.get(resolvedSvg.svgPath));
+            return new Response(resolvedSvg.svgContent, resolvedSvg.options);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spirobel/mininext",
-  "license" : "MIT" ,
+  "license": "MIT",
   "module": "dist/mininext/mininext.js",
   "type": "module",
   "main": "dist/mininext.js",
@@ -8,10 +8,10 @@
   "scripts": {
     "publish": "bun run build && npm publish",
     "build": "tsc",
-    "clean":"rm -rf ./dist"
+    "clean": "rm -rf ./dist"
   },
   "files": ["dist"],
-  "version": "0.5.1",
+  "version": "0.6.1",
   "devDependencies": {
     "@types/bun": "latest"
   },