@davidsouther/jiffies 1.0.0 → 1.1.0

package/build/server/http/css.js

@@ -1,47 +1,50 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { contentResponse } from "./response.js";
-import sass from "sass";
-const { compileStringAsync } = sass;
-function render(source) {
-    // Replace `from "@scope` with `from "/@scope`, for browsers
-    // source = source
-    //   .replaceAll(`from "@`, 'from "/@')
-    //   .replaceAll(`import("@`, 'import("/@');
-    return contentResponse(source, "text/css");
-}
-async function compile(filename, root, vars) {
-    vars = vars.substring(1).replaceAll("=", ":");
-    const sassString = `// Using variables: ${vars}\n${vars};\n@import "${filename}";`;
-    return (await compileStringAsync(sassString, { loadPaths: [root] })).css;
-}
-/**
- * Serves .css files statically. Finds .sass files and transpiles them to css.
- */
-export const cssFileServer = async ({ root, scopes = {} }) => async (req) => {
-    const Url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    if (Url.pathname.endsWith(".css")) {
-        let scope = Object.entries(scopes).find(([s]) => Url.pathname.startsWith(`/${s}`));
-        // Expand url with found scope
-        let url = scope ? Url.pathname.replace(scope[0], scope[1]) : Url.pathname;
-        let filename = path.join(root, url);
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const css = (await fs.readFile(filename)).toString("utf-8");
-                return render(css);
-            }
-        }
-        catch { }
-        filename = filename.replace(/\.css$/, ".scss");
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const css = await compile(filename.replace(root, "."), root, Url.search);
-                return render(css);
-            }
-        }
-        catch { }
-    }
-    return undefined;
-};
+import * as fs from "fs/promises";
+import * as path from "path";
+import { contentResponse } from "./response.js";
+// @ts-ignore
+import sass from "sass";
+const { compileStringAsync } = sass;
+function render(source) {
+    // Replace `from "@scope` with `from "/@scope`, for browsers
+    // source = source
+    //   .replaceAll(`from "@`, 'from "/@')
+    //   .replaceAll(`import("@`, 'import("/@');
+    return contentResponse(source, "text/css");
+}
+async function compile(filename, root, vars) {
+    vars = vars.substring(1).replaceAll("=", ":");
+    filename = filename.replaceAll("\\", "/"); // Normalize for dart-sass
+    const sassString = `// Using variables: ${vars}\n${vars};\n@import "${filename}";`;
+    return (await compileStringAsync(sassString, { loadPaths: [root] })).css;
+}
+/**
+ * Serves .css files statically. Finds .sass files and transpiles them to css.
+ */
+export const cssFileServer = async ({ root, scopes = {} }) => async (req) => {
+    const Url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (Url.pathname.endsWith(".css")) {
+        let scope = Object.entries(scopes).find(([s]) => Url.pathname.startsWith(`/${s}`));
+        // Expand url with found scope
+        Url.protocol = "file";
+        let url = scope ? Url.pathname.replace(scope[0], scope[1]) : Url.pathname;
+        let filename = path.join(root, url);
+        try {
+            const stat = await fs.stat(filename);
+            if (stat.isFile()) {
+                const css = (await fs.readFile(filename)).toString("utf-8");
+                return render(css);
+            }
+        }
+        catch { }
+        filename = filename.replace(/\.css$/, ".scss");
+        try {
+            const stat = await fs.stat(filename);
+            if (stat.isFile()) {
+                const css = await compile(filename.replace(root, "."), root, Url.search);
+                return render(css);
+            }
+        }
+        catch { }
+    }
+    return undefined;
+};

package/build/server/http/index.d.ts

@@ -1,21 +1,21 @@
-#!/usr/bin/env node
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage } from "http";
-export interface StaticResponse {
-    status: 200 | 404 | 500;
-    content: Buffer;
-    contentType: string;
-    contentLength?: number;
-}
-export interface ServerConfig {
-    root: string;
-    scopes?: Record<`@${string}`, string>;
-}
-export interface MiddlewareFactory {
-    (config: ServerConfig): Promise<StaticMiddleware>;
-}
-export interface StaticMiddleware {
-    (req: IncomingMessage): Promise<undefined | (() => Promise<StaticResponse>)>;
-}
-export declare const makeServer: (config: ServerConfig, middlewares?: MiddlewareFactory[]) => Promise<import("http").Server>;
+#!/usr/bin/env node
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+export interface StaticResponse {
+    status: 200 | 404 | 500;
+    content: Buffer;
+    contentType: string;
+    contentLength?: number;
+}
+export interface ServerConfig {
+    root: string;
+    scopes?: Record<`@${string}`, string>;
+}
+export interface MiddlewareFactory {
+    (config: ServerConfig): Promise<StaticMiddleware>;
+}
+export interface StaticMiddleware {
+    (req: IncomingMessage): Promise<undefined | (() => Promise<StaticResponse>)>;
+}
+export declare const makeServer: (config: ServerConfig, middlewares?: MiddlewareFactory[]) => Promise<import("http").Server>;

package/build/server/http/index.js

@@ -1,73 +1,73 @@
-#!/usr/bin/env node
-import { createServer, } from "http";
-import * as path from "path";
-import { info } from "../../log.js";
-import { findIndex } from "./apps.js";
-import { cssFileServer } from "./css.js";
-import { fileResponse } from "./response.js";
-import { sitemap } from "./sitemap.js";
-import { staticFileServer } from "./static.js";
-import { tsFileServer } from "./typescript.js";
-const notFound = async ({ root }) => async () => fileResponse(
-// path.join(path.dirname(FLAGS.argv0), "404.html"),
-path.join(root, "404.html"), undefined, 404);
-const BASE_MIDDLEWARES = [
-    sitemap,
-    tsFileServer,
-    cssFileServer,
-    staticFileServer,
-    findIndex,
-    notFound,
-];
-const error = (res, message) => {
-    console.error(message);
-    res.statusCode = 500;
-    res.write(message);
-    res.end();
-    return true;
-};
-const sendContent = async (res, { content, contentType, contentLength }) => {
-    res.setHeader("Content-Length", `${contentLength}`);
-    res.setHeader("Content-Type", contentType);
-    await res.write(content);
-    res.end();
-    return true;
-};
-const log = (req) => {
-    const when = new Date().toISOString();
-    const who = req.socket.remoteAddress;
-    const what = req.url;
-    const how = `${req.method} ${what}`;
-    info("Request", { when, who, how });
-};
-export const makeServer = async (config, middlewares = []) => {
-    const handlers = await Promise.all([...middlewares, ...BASE_MIDDLEWARES].map(async (m) => m(config)));
-    const middlewareHandler = async (req, res) => {
-        log(req);
-        let handler;
-        try {
-            for (const middleware of handlers) {
-                handler = await middleware(req);
-                if (handler !== undefined) {
-                    break;
-                }
-            }
-            if (handler) {
-                sendContent(res, await handler());
-            }
-            else {
-                res.end();
-            }
-        }
-        catch (e) {
-            error(res, e.message + "\n" + e.stack);
-        }
-    };
-    // TODO(https)
-    const server = createServer(middlewareHandler);
-    server.on("listening", () => {
-        const { address, port } = server.address();
-        info("Server listening", { address: `http://${address}:${port}` });
-    });
-    return server;
-};
+#!/usr/bin/env node
+import { createServer, } from "http";
+import * as path from "path";
+import { info } from "../../log.js";
+import { findIndex } from "./apps.js";
+import { cssFileServer } from "./css.js";
+import { fileResponse } from "./response.js";
+import { sitemap } from "./sitemap.js";
+import { staticFileServer } from "./static.js";
+import { tsFileServer } from "./typescript.js";
+const notFound = async ({ root }) => async () => fileResponse(
+// path.join(path.dirname(FLAGS.argv0), "404.html"),
+path.join(root, "404.html"), undefined, 404);
+const BASE_MIDDLEWARES = [
+    sitemap,
+    tsFileServer,
+    cssFileServer,
+    staticFileServer,
+    findIndex,
+    notFound,
+];
+const error = (res, message) => {
+    console.error(message);
+    res.statusCode = 500;
+    res.write(message);
+    res.end();
+    return true;
+};
+const sendContent = async (res, { content, contentType, contentLength }) => {
+    res.setHeader("Content-Length", `${contentLength}`);
+    res.setHeader("Content-Type", contentType);
+    await res.write(content);
+    res.end();
+    return true;
+};
+const log = (req) => {
+    const when = new Date().toISOString();
+    const who = req.socket.remoteAddress;
+    const what = req.url;
+    const how = `${req.method} ${what}`;
+    info("Request", { when, who, how });
+};
+export const makeServer = async (config, middlewares = []) => {
+    const handlers = await Promise.all([...middlewares, ...BASE_MIDDLEWARES].map(async (m) => m(config)));
+    const middlewareHandler = async (req, res) => {
+        log(req);
+        let handler;
+        try {
+            for (const middleware of handlers) {
+                handler = await middleware(req);
+                if (handler !== undefined) {
+                    break;
+                }
+            }
+            if (handler) {
+                sendContent(res, await handler());
+            }
+            else {
+                res.end();
+            }
+        }
+        catch (e) {
+            error(res, e.message + "\n" + e.stack);
+        }
+    };
+    // TODO(https)
+    const server = createServer(middlewareHandler);
+    server.on("listening", () => {
+        const { address, port } = server.address();
+        info("Server listening", { address: `http://${address}:${port}` });
+    });
+    return server;
+};

package/build/server/http/response.d.ts

@@ -1,4 +1,4 @@
-import { Stats } from "fs";
-import { StaticResponse } from ".";
-export declare const fileResponse: (filename: string, stat?: Stats, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;
-export declare const contentResponse: (content: string, contentType: string, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;
+import { Stats } from "fs";
+import { StaticResponse } from ".";
+export declare const fileResponse: (filename: string, stat?: Stats, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;
+export declare const contentResponse: (content: string, contentType: string, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;

package/build/server/http/response.js

@@ -1,40 +1,40 @@
-import * as fs from "fs/promises";
-const MIME_TYPES = {
-    js: "text/javascript",
-    json: "text/javascript",
-    css: "text/css",
-    html: "text/html",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    svg: "image/svg+xml",
-    eot: "application/vnd.ms-fontobject",
-    ttf: "application/font-ttf",
-    woff: "application/font-woff",
-    woff2: "application/font-woff2",
-};
-const mime = (basename) => {
-    const extension = basename
-        .substring(basename.lastIndexOf(".") + 1)
-        .toLowerCase();
-    return MIME_TYPES[extension] ?? "application/octet-stream";
-};
-export const fileResponse = (filename, stat, status = 200) => async () => {
-    if (!stat) {
-        stat = await fs.stat(filename);
-    }
-    const content = await fs.readFile(filename);
-    const contentType = mime(filename);
-    const contentLength = stat.size;
-    return { status, contentType, contentLength, content };
-};
-const CHARSET = "utf-8";
-export const contentResponse = (content, contentType, status = 200) => async () => {
-    const contentBuffer = Buffer.from(content, CHARSET);
-    return {
-        content: contentBuffer,
-        contentType: contentType.split(";")[0] + "; charset=" + CHARSET,
-        status,
-        contentLength: contentBuffer.length,
-    };
-};
+import * as fs from "fs/promises";
+const MIME_TYPES = {
+    js: "text/javascript",
+    json: "text/javascript",
+    css: "text/css",
+    html: "text/html",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    svg: "image/svg+xml",
+    eot: "application/vnd.ms-fontobject",
+    ttf: "application/font-ttf",
+    woff: "application/font-woff",
+    woff2: "application/font-woff2",
+};
+const mime = (basename) => {
+    const extension = basename
+        .substring(basename.lastIndexOf(".") + 1)
+        .toLowerCase();
+    return MIME_TYPES[extension] ?? "application/octet-stream";
+};
+export const fileResponse = (filename, stat, status = 200) => async () => {
+    if (!stat) {
+        stat = await fs.stat(filename);
+    }
+    const content = await fs.readFile(filename);
+    const contentType = mime(filename);
+    const contentLength = stat.size;
+    return { status, contentType, contentLength, content };
+};
+const CHARSET = "utf-8";
+export const contentResponse = (content, contentType, status = 200) => async () => {
+    const contentBuffer = Buffer.from(content, CHARSET);
+    return {
+        content: contentBuffer,
+        contentType: contentType.split(";")[0] + "; charset=" + CHARSET,
+        status,
+        contentLength: contentBuffer.length,
+    };
+};

package/build/server/http/sitemap.d.ts

@@ -1,2 +1,2 @@
-import { MiddlewareFactory } from "./index.js";
-export declare const sitemap: MiddlewareFactory;
+import { MiddlewareFactory } from "./index.js";
+export declare const sitemap: MiddlewareFactory;

package/build/server/http/sitemap.js

@@ -1,42 +1,42 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { info } from "../../log.js";
-import { contentResponse } from "./response.js";
-const findSiteMap = async (root, prefix = root) => {
-    if (root.startsWith("node_modules")) {
-        return [];
-    }
-    const children = (await fs.readdir(root, { withFileTypes: true })).map(async (entry) => {
-        const next = path
-            .join(root, entry.name)
-            // Normalize separators for web
-            .replaceAll(path.sep, "/");
-        if (entry.isFile()) {
-            if (entry.name === "index.html") {
-                let index = next.replace(prefix, "");
-                info(`Adding to sitemap`, { index });
-                return [index];
-            }
-        }
-        else if (entry.isDirectory()) {
-            if (entry.name.startsWith(".")) {
-                return [];
-            }
-            const flattened = (await Promise.all(await findSiteMap(next, prefix))).flat();
-            return flattened;
-        }
-        return [];
-    });
-    return children;
-};
-export const sitemap = async ({ root }) => {
-    const apps = await (await Promise.all(await findSiteMap(root)))
-        .flat()
-        .filter((a) => a !== undefined);
-    return async (req) => {
-        if ((req.url ?? "").endsWith("sitemap.json")) {
-            return contentResponse(JSON.stringify(apps), "application/json");
-        }
-        return undefined;
-    };
-};
+import * as fs from "fs/promises";
+import * as path from "path";
+import { info } from "../../log.js";
+import { contentResponse } from "./response.js";
+const findSiteMap = async (root, prefix = root) => {
+    if (root.startsWith("node_modules")) {
+        return [];
+    }
+    const children = (await fs.readdir(root, { withFileTypes: true })).map(async (entry) => {
+        const next = path
+            .join(root, entry.name)
+            // Normalize separators for web
+            .replaceAll(path.sep, "/");
+        if (entry.isFile()) {
+            if (entry.name === "index.html") {
+                let index = next.replace(prefix, "");
+                info(`Adding to sitemap`, { index });
+                return [index];
+            }
+        }
+        else if (entry.isDirectory()) {
+            if (entry.name.startsWith(".")) {
+                return [];
+            }
+            const flattened = (await Promise.all(await findSiteMap(next, prefix))).flat();
+            return flattened;
+        }
+        return [];
+    });
+    return children;
+};
+export const sitemap = async ({ root }) => {
+    const apps = await (await Promise.all(await findSiteMap(root)))
+        .flat()
+        .filter((a) => a !== undefined);
+    return async (req) => {
+        if ((req.url ?? "").endsWith("sitemap.json")) {
+            return contentResponse(JSON.stringify(apps), "application/json");
+        }
+        return undefined;
+    };
+};

package/build/server/http/static.d.ts

@@ -1,2 +1,2 @@
-import type { MiddlewareFactory } from "./index.js";
-export declare const staticFileServer: MiddlewareFactory;
+import type { MiddlewareFactory } from "./index.js";
+export declare const staticFileServer: MiddlewareFactory;

package/build/server/http/static.js

@@ -1,21 +1,21 @@
-import * as path from "path";
-import * as fs from "fs/promises";
-import { fileResponse } from "./response.js";
-export const staticFileServer = async ({ root, scopes = {} }) => async (req) => {
-    const scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
-    const url = new URL(req.url ?? "", `http://localhost`);
-    const pathname = scope
-        ? url.pathname.replace(scope[0], scope[1])
-        : url.pathname;
-    const filename = path.join(root, pathname);
-    // Expand url with found scope
-    console.log(scope, req.url, filename);
-    try {
-        const stat = await fs.stat(filename);
-        return stat.isDirectory() ? undefined : fileResponse(filename, stat);
-    }
-    catch (e) {
-        console.error(e);
-        return undefined;
-    }
-};
+import * as path from "path";
+import * as fs from "fs/promises";
+import { fileResponse } from "./response.js";
+export const staticFileServer = async ({ root, scopes = {} }) => async (req) => {
+    const scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
+    const url = new URL(req.url ?? "", `http://localhost`);
+    const pathname = scope
+        ? url.pathname.replace(scope[0], scope[1])
+        : url.pathname;
+    const filename = path.join(root, pathname);
+    // Expand url with found scope
+    console.log(scope, req.url, filename);
+    try {
+        const stat = await fs.stat(filename);
+        return stat.isDirectory() ? undefined : fileResponse(filename, stat);
+    }
+    catch (e) {
+        console.error(e);
+        return undefined;
+    }
+};

package/build/server/http/typescript.d.ts

@@ -1,5 +1,5 @@
-import { MiddlewareFactory } from "./index.js";
-/**
- * Serves .js files statically. Finds .ts files and transpiles them to JS.
- */
-export declare const tsFileServer: MiddlewareFactory;
+import { MiddlewareFactory } from "./index.js";
+/**
+ * Serves .js files statically. Finds .ts files and transpiles them to JS.
+ */
+export declare const tsFileServer: MiddlewareFactory;

package/build/server/http/typescript.js

@@ -1,40 +1,40 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { contentResponse } from "./response.js";
-import { transpile } from "../../transpile.mjs";
-function render(source) {
-    // Replace `from "@scope` with `from "/@scope`, for browsers
-    source = source
-        .replaceAll(`from "@`, 'from "/@')
-        .replaceAll(`import("@`, 'import("/@');
-    return contentResponse(source, "application/javascript");
-}
-/**
- * Serves .js files statically. Finds .ts files and transpiles them to JS.
- */
-export const tsFileServer = async ({ root, scopes = {} }) => async (req) => {
-    if (req.url?.endsWith(".js")) {
-        let scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
-        // Expand url with found scope
-        let url = scope ? req.url.replace(scope[0], scope[1]) : req.url;
-        let filename = path.join(root, url);
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const js = (await fs.readFile(filename)).toString("utf-8");
-                return render(js);
-            }
-        }
-        catch { }
-        filename = filename.replace(/\.js$/, ".ts");
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const js = await transpile(filename, () => fs.readFile(filename));
-                return render(js);
-            }
-        }
-        catch { }
-    }
-    return undefined;
-};
+import * as fs from "fs/promises";
+import * as path from "path";
+import { contentResponse } from "./response.js";
+import { transpile } from "../../transpile.mjs";
+function render(source) {
+    // Replace `from "@scope` with `from "/@scope`, for browsers
+    source = source
+        .replaceAll(`from "@`, 'from "/@')
+        .replaceAll(`import("@`, 'import("/@');
+    return contentResponse(source, "application/javascript");
+}
+/**
+ * Serves .js files statically. Finds .ts files and transpiles them to JS.
+ */
+export const tsFileServer = async ({ root, scopes = {} }) => async (req) => {
+    if (req.url?.endsWith(".js")) {
+        let scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
+        // Expand url with found scope
+        let url = scope ? req.url.replace(scope[0], scope[1]) : req.url;
+        let filename = path.join(root, url);
+        try {
+            const stat = await fs.stat(filename);
+            if (stat.isFile()) {
+                const js = (await fs.readFile(filename)).toString("utf-8");
+                return render(js);
+            }
+        }
+        catch { }
+        filename = filename.replace(/\.js$/, ".ts");
+        try {
+            const stat = await fs.stat(filename);
+            if (stat.isFile()) {
+                const js = await transpile(filename, () => fs.readFile(filename));
+                return render(js);
+            }
+        }
+        catch { }
+    }
+    return undefined;
+};

package/build/server/main.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node --experimental-loader ../loader.mjs
-export {};
+#!/usr/bin/env node --experimental-loader ../loader.mjs
+export {};

package/build/server/main.js

@@ -1,9 +1,9 @@
-#!/usr/bin/env node --experimental-loader ../loader.mjs
-import { info } from "../log.js";
-info("Starting server", { cwd: process.cwd() });
-import { parse } from "../flags.js";
-const FLAGS = parse(process.argv);
-import { makeServer } from "./http/index.js";
-import * as path from "node:path";
-const server = await makeServer({ root: path.join(process.cwd(), "src") });
-server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));
+#!/usr/bin/env node --experimental-loader ../loader.mjs
+import { info } from "../log.js";
+info("Starting server", { cwd: process.cwd() });
+import { parse } from "../flags.js";
+const FLAGS = parse(process.argv);
+import { makeServer } from "./http/index.js";
+import * as path from "node:path";
+const server = await makeServer({ root: path.join(process.cwd(), "src") });
+server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));

package/build/test.d.mts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
-export {};
+#!/usr/bin/env node
+export {};