@davidsouther/jiffies 1.0.0-beta.1 → 1.0.0

package/build/components/button_bar.js

@@ -1,16 +1,27 @@
 import { display } from "../display.js";
 import { FC } from "../dom/fc.js";
-import { a, li, ul } from "../dom/html.js";
-const ButtonBar = FC("button-bar", (el, { value, values, events }) => ul({ class: "ButtonBar__wrapper" }, ...values.map((option) => li(a({
-    href: "#",
-    class: `ButtonBar__${`${option}`.replace(/\s+/g, "_").toLowerCase()}
-                ${option === value ? "" : "secondary"}
-                `.replace(/[\n\s]+/, " "),
-    events: {
-        click: (e) => {
-            e.preventDefault();
-            events.onSelect(option);
-        },
-    },
-}, display(option))))));
+import { fieldset, input, label } from "../dom/html.js";
+let buttonBarId = 1;
+let nextId = () => buttonBarId++;
+const ButtonBar = FC("button-bar", (el, { value, values, events }) => {
+    const name = `button-bar-${nextId()}`;
+    return fieldset({ class: "input-group" }, ...values
+        .map((option) => {
+        const opt = `${option}`.replace(/\s+/g, "_").toLowerCase();
+        const id = `${name}-${opt}`;
+        return [
+            label({ role: "button", htmlFor: id }, input({
+                type: "radio",
+                id,
+                name,
+                value: option,
+                checked: option === value,
+                events: {
+                    change: () => events.onSelect(option),
+                },
+            }), display(option)),
+        ];
+    })
+        .flat());
+});
 export default ButtonBar;

package/build/components/select.d.ts

@@ -6,8 +6,5 @@ export declare const Select: import("../dom/fc.js").FCComponentCtor<{
         change: EventHandler;
     };
     disabled: boolean;
-    options: [
-        string,
-        string
-    ][];
+    options: [string, string][];
 }, {}>;

package/build/display.js

@@ -1,3 +1,11 @@
 export const isDisplay = (/** @type unknown */ a) => typeof a.toString === "function" ||
     typeof a === "string";
-export const display = (a) => isDisplay(a) ? a.toString() : JSON.stringify(a);
+export const display = (a) => {
+    if (isDisplay(a)) {
+        const str = a.toString();
+        if (str === "[object Object]")
+            return JSON.stringify(a);
+        return str;
+    }
+    return JSON.stringify(a);
+};

package/build/dom/dom.js

@@ -58,6 +58,7 @@ export function update(element, attrs, children) {
                 .forEach((c) => element.classList.add(c));
         }
         let useAttributes = k.startsWith("aria-") ||
+            k == "role" ||
             element.namespaceURI != "http://www.w3.org/1999/xhtml";
         if (useAttributes) {
             switch (v) {

package/build/dom/form/form.d.ts

@@ -1,21 +1,22 @@
 import { DenormChildren } from "../dom.js";
 import { label } from "../html.js";
-import { FormAttributes, InputAttributes, OptionAttributes, SelectAttributes } from "../types/html.js";
+import { FormAttributes, InputAttributes, LabelAttributes, OptionAttributes, SelectAttributes } from "../types/html.js";
 export declare const Form: (attrs: FormAttributes, ...children: DenormChildren[]) => import("../html.js").UHTMLElement<HTMLFormElement>;
 export declare const Input: (attrs: InputAttributes, ...children: DenormChildren[]) => import("../html.js").UHTMLElement<HTMLLabelElement>;
-export declare const Select: ({ options }: {
+export declare const Select: (attrs: {
     options: string[] | {};
-}) => import("../html.js").UHTMLElement<HTMLLabelElement>;
+    selected?: string;
+} & SelectAttributes & LabelAttributes) => import("../html.js").UHTMLElement<HTMLLabelElement>;
 export declare const Button: () => void;
 declare const prepareOptions: (attrs: string[] | Record<string, string | {
     label: string;
-    disabled?: boolean;
-    selected?: boolean;
-}>) => Parameters<typeof Option>[0][];
+    disabled?: boolean | undefined;
+    selected?: boolean | undefined;
+}>, selected?: string) => Parameters<typeof Option>[0][];
 export declare const Option: (attrs: OptionAttributes) => import("../html.js").UHTMLElement<HTMLOptionElement>;
 export declare const Dropdown: (attrs: SelectAttributes | {
-    options: Parameters<typeof prepareOptions>[0];
-}) => void;
+    selected?: string;
+}, ...options: Parameters<typeof prepareOptions>[0][]) => import("../html.js").UHTMLElement<HTMLLabelElement>;
 export declare const Radios: () => void;
 export declare const Checks: () => void;
 export declare const Switches: () => void;

package/build/dom/form/form.js

@@ -10,13 +10,22 @@ export const Form = (attrs, ...children) => {
     return form(attrs, ...children);
 };
 export const Input = (attrs, ...children) => label(input(attrs), ...children);
-export const Select = ({ options }) => label(select(...prepareOptions(options).map(Option)));
+export const Select = (attrs) => label({ style: attrs.style ?? {} }, select({ events: attrs.events ?? {} }, ...prepareOptions(attrs.options, attrs.selected).map(Option)));
 export const Button = () => { };
-const prepareOptions = (attrs) => Array.isArray(attrs)
-    ? attrs.map((value) => ({ value, label: value }))
-    : Object.entries(attrs).map(([value, label]) => typeof label === "string" ? { value, label } : { value, ...label });
+const prepareOptions = (attrs, selected) => Array.isArray(attrs)
+    ? attrs.map((value) => ({
+        value,
+        label: value,
+        selected: selected == value,
+    }))
+    : Object.entries(attrs).map(([value, label]) => typeof label === "string"
+        ? { value, label, selected: selected === value }
+        : { value, ...label });
 export const Option = (attrs) => option(attrs);
-export const Dropdown = (attrs) => { };
+export const Dropdown = (attrs, ...options) => Select({
+    ...attrs,
+    options: typeof options[0] == "string" ? options : options[0],
+});
 export const Radios = () => { };
 export const Checks = () => { };
 export const Switches = () => { };

package/build/dom/provide.d.ts

@@ -0,0 +1,3 @@
+import { Option } from "../result.js";
+export declare function provide(items: Record<string, unknown>): void;
+export declare function retrieve<T>(key: string): Option<T>;

package/build/dom/provide.js

@@ -0,0 +1,7 @@
+let registry = {};
+export function provide(items) {
+    registry = { ...registry, ...items };
+}
+export function retrieve(key) {
+    return registry[key];
+}

package/build/equal.d.ts

@@ -1,4 +1,5 @@
-export declare function compareArrays<T>(equal: (a: T, b: T) => boolean): (A: T[], B: T[]) => boolean;
-export declare const equalArrays: (A: any[], B: any[]) => boolean;
-export declare const matchArrays: <A>(a: A[], b: A[]) => boolean;
-export declare function equals<A>(a: A | A[], b: A | A[]): boolean;
+export declare function compareArrays<T>(equal: (a: T, b: T, partial: boolean) => boolean): (A: T[], B: T[], partial?: boolean) => boolean;
+export declare const equalArrays: (A: any[], B: any[], partial?: boolean) => boolean;
+export declare const matchArrays: <A>(a: A[], b: A[], partial?: boolean) => boolean;
+export declare const matchObjects: (a: {}, b: {}, partial?: boolean) => boolean;
+export declare function equals<A>(a: A | A[], b: A | A[], partial?: boolean): boolean;

package/build/equal.js

@@ -1,21 +1,36 @@
 export function compareArrays(equal) {
-    return (a, b) => a.length === b.length && a.every((e, i) => equal(e, b[i]));
+    return (a, b, partial = false) => a.length === b.length && a.every((e, i) => equal(e, b[i], partial));
 }
 export const equalArrays = compareArrays(Object.is);
 export const matchArrays = compareArrays(equals);
 function asArray(a) {
     return Object.entries(a).sort((a, b) => a[0].localeCompare(b[0]));
 }
-export function equals(a, b) {
+export const matchObjects = (a, b, partial = true) => {
+    for (const [k, v] of Object.entries(a)) {
+        if (!b.hasOwnProperty(k) && partial)
+            continue;
+        // @ts-ignore
+        if (!equals(v, b[k], partial))
+            return false;
+    }
+    return true;
+};
+export function equals(a, b, partial = false) {
     // runtime type checking
     switch (typeof a) {
         case "object":
+            if (b === undefined) {
+                return false;
+            }
             if (a instanceof Array && b instanceof Array) {
-                return matchArrays(a, b);
+                return matchArrays(a, b, partial);
             }
             else {
-                return matchArrays(asArray(a), asArray(b));
+                return matchObjects(a, b, partial);
             }
+        case "function":
+            return a.name == b.name;
         default:
             return Object.is(a, b);
     }

package/build/fs.d.ts

@@ -0,0 +1,48 @@
+export declare type PathLike = string;
+export interface Stats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+interface FileSystemAdapter {
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+}
+export declare class FileSystem implements FileSystemAdapter {
+    protected adapter: ObjectFileSystemAdapter;
+    protected wd: string;
+    protected stack: string[];
+    constructor(adapter?: ObjectFileSystemAdapter);
+    cwd(): string;
+    cd(dir: string): void;
+    pushd(dir: string): void;
+    popd(): void;
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+    private p;
+}
+export declare class ObjectFileSystemAdapter implements FileSystemAdapter {
+    private fs;
+    constructor(fs?: Record<string, string>);
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+}
+export declare class LocalStorageFileSystemAdapter extends ObjectFileSystemAdapter {
+    constructor();
+}
+export interface Tree {
+    [k: string]: string | Tree;
+}
+export declare function reset(fs: FileSystem, tree: Tree): Promise<void>;
+export {};

package/build/fs.js

@@ -0,0 +1,144 @@
+function join(...paths) {
+    const pathParts = [];
+    for (const path of paths) {
+        for (const part of path.split("/")) {
+            switch (part) {
+                case "":
+                case ".":
+                    break;
+                case "..":
+                    pathParts.pop();
+                    break;
+                default:
+                    pathParts.push(part);
+            }
+        }
+    }
+    return "/" + pathParts.join("/");
+}
+export class FileSystem {
+    adapter;
+    wd = "/";
+    stack = [];
+    constructor(adapter = new ObjectFileSystemAdapter()) {
+        this.adapter = adapter;
+    }
+    cwd() {
+        return this.wd;
+    }
+    cd(dir) {
+        this.wd = this.p(dir);
+    }
+    pushd(dir) {
+        this.stack.push(this.wd);
+        this.cd(dir);
+    }
+    popd() {
+        if (this.stack.length > 0) {
+            this.wd = this.stack.pop();
+        }
+    }
+    stat(path) {
+        return this.adapter.stat(join(this.cwd(), path));
+    }
+    readdir(path) {
+        return this.adapter.readdir(this.p(path) + "/");
+    }
+    copyFile(from, to) {
+        return this.adapter.copyFile(this.p(from), this.p(to));
+    }
+    readFile(path) {
+        return this.adapter.readFile(this.p(path));
+    }
+    writeFile(path, contents) {
+        return this.adapter.writeFile(this.p(path), contents);
+    }
+    rm(path) {
+        return this.adapter.rm(this.p(path));
+    }
+    p(path) {
+        return path[0] == "/" ? path : join(this.cwd(), path);
+    }
+}
+export class ObjectFileSystemAdapter {
+    fs;
+    constructor(fs = {}) {
+        this.fs = fs;
+    }
+    stat(path) {
+        return new Promise((resolve, reject) => {
+            if (this.fs[path] != null) {
+                resolve({
+                    isDirectory() {
+                        return false;
+                    },
+                    isFile() {
+                        return true;
+                    },
+                });
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    readdir(path) {
+        return new Promise((resolve) => {
+            let dir = [];
+            for (const filename of Object.keys(this.fs)) {
+                if (filename.startsWith(path)) {
+                    const end = filename.indexOf("/", path.length + 1);
+                    const basename = filename.substring(path.length, end == -1 ? undefined : end);
+                    dir.push(basename);
+                }
+            }
+            return resolve(dir);
+        });
+    }
+    copyFile(from, to) {
+        return new Promise((resolve) => {
+            this.fs[to] = this.fs[from];
+            resolve();
+        });
+    }
+    readFile(path) {
+        return new Promise((resolve, reject) => {
+            let file = this.fs[path];
+            if (file === undefined) {
+                reject();
+            }
+            else {
+                resolve(file);
+            }
+        });
+    }
+    writeFile(path, contents) {
+        return new Promise((resolve) => {
+            this.fs[path] = contents;
+            resolve();
+        });
+    }
+    rm(path) {
+        return new Promise((resolve) => {
+            delete this.fs[path];
+            resolve();
+        });
+    }
+}
+export class LocalStorageFileSystemAdapter extends ObjectFileSystemAdapter {
+    constructor() {
+        super(window.localStorage);
+    }
+}
+export async function reset(fs, tree) {
+    for (const [path, file] of Object.entries(tree)) {
+        if (typeof file == "string") {
+            await fs.writeFile(path, file);
+        }
+        else {
+            fs.cd(path);
+            await reset(fs, file);
+            fs.cd("..");
+        }
+    }
+}

package/build/fs.test.js

@@ -0,0 +1,43 @@
+import { FileSystem, ObjectFileSystemAdapter } from "./fs.js";
+import { describe, it, expect } from "./scope/index.js";
+describe("FileSystem", () => {
+    describe("Writing", () => {
+        it("Writes files", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("hello", "world");
+            expect(fsObj).toEqual({ "/hello": "world" });
+        });
+        it("Writes deep files", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("deep/hello", "world");
+            expect(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+        it("Writes deep files from root", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("/root/deep/hello", "world");
+            expect(fsObj).toEqual({ "/root/deep/hello": "world" });
+        });
+        it("Writes files after cd", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.cd("deep");
+            await fs.writeFile("hello", "world");
+            expect(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+    });
+    describe("directory", () => {
+        it("returns directory listing", async () => {
+            const fsObj = {
+                "/deep/hello": "world",
+                "/deep/bonjour": "monde",
+                "/other/file": "text",
+            };
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            const dir = await fs.readdir("deep");
+            expect(dir.sort()).toEqual(["bonjour", "hello"]);
+        });
+    });
+});

package/build/log.js

@@ -21,14 +21,26 @@ export function getLogger(name) {
 }
 export const DEFAULT_LOGGER = getLogger("default");
 export function debug(message, data) {
-    DEFAULT_LOGGER.debug(message, data);
+    if (data)
+        DEFAULT_LOGGER.debug(message, data);
+    else
+        DEFAULT_LOGGER.debug(message);
 }
 export function info(message, data) {
-    DEFAULT_LOGGER.info(message, data);
+    if (data)
+        DEFAULT_LOGGER.info(message, data);
+    else
+        DEFAULT_LOGGER.info(message);
 }
 export function warn(message, data) {
-    DEFAULT_LOGGER.warn(message, data);
+    if (data)
+        DEFAULT_LOGGER.warn(message, data);
+    else
+        DEFAULT_LOGGER.warn(message);
 }
 export function error(message, data) {
-    DEFAULT_LOGGER.error(message, data);
+    if (data)
+        DEFAULT_LOGGER.error(message, data);
+    else
+        DEFAULT_LOGGER.error(message);
 }

package/build/result.d.ts

@@ -1,7 +1,7 @@
 export declare type None = null;
 export declare type Some<T> = T;
 export declare type Option<T> = Some<T> | None;
-export declare type Err<E extends Error> = {
+export declare type Err<E = Error> = {
     err: E;
     map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
 };
@@ -9,23 +9,23 @@ export declare type Ok<T> = {
     ok: T;
     map: <U>(fn: (t: T) => Result<U>) => Result<U>;
 };
-export declare type Result<T, E extends Error = Error> = Ok<T> | Err<E>;
+export declare type Result<T, E = Error> = Ok<T> | Err<E>;
 export declare const isNone: <T>(s: Option<T>) => s is null;
 export declare const isSome: <T>(s: Option<T>) => s is T;
 export declare function None<T = unknown>(_?: T): Option<T>;
 export declare function Some<T>(t: Option<T>): Option<T>;
 export declare function Some<T>(t: T): Option<T>;
-export declare const isOk: <T, E extends Error>(t: Result<T, E>) => t is Ok<T>;
-export declare const isErr: <T, E extends Error>(e: Result<T, E>) => boolean;
-export declare const isResult: <T, E extends Error>(t: Result<T, E>) => t is Result<T, E>;
+export declare const isOk: <T, E>(t: Result<T, E>) => t is Ok<T>;
+export declare const isErr: <T, E>(e: Result<T, E>) => e is Err<E>;
+export declare const isResult: <T, E>(t: Result<T, E>) => t is Result<T, E>;
 export declare function Ok<T>(ok: Ok<T>): T;
 export declare function Ok<T>(t: T): Ok<T>;
-export declare function Err<E extends Error>(e: Err<E>): E;
-export declare function Err<E extends Error>(e: E): Err<E>;
-export declare function Err<E extends Error>(e: string): Err<E>;
-export declare function unwrap<T, E extends Error>(result: Result<T, E>): T | never;
+export declare function Err<E>(e: Err<E>): E;
+export declare function Err<E>(e: E): Err<E>;
+export declare function Err<E>(e: string): Err<E>;
+export declare function unwrap<T, E>(result: Result<T, E>): T | never;
 export declare function unwrap<O>(some: Option<O>): O | never;
-export declare function unwrapOr<T, E extends Error>(result: Result<T, E>, def: T): T;
+export declare function unwrapOr<T, E>(result: Result<T, E>, def: T): T;
 export declare function unwrapOr<T>(some: Some<T>, def: T): T;
-export declare function unwrapOrElse<T, E extends Error>(result: Result<T, Error>, def: () => T): T;
+export declare function unwrapOrElse<T, E>(result: Result<T, Error>, def: () => T): T;
 export declare function unwrapOrElse<T>(some: Some<T>, def: () => T): T;

package/build/result.js

@@ -21,8 +21,8 @@ export function Ok(t) {
 }
 export function Err(e) {
     return (e.err ?? {
-        err: typeof e === "string" ? new Error(e) : e,
-        map(fn) {
+        err: e,
+        map(_fn) {
             return this;
         },
     });

package/build/scope/execute.js

@@ -66,7 +66,7 @@ function makeResult(test, result) {
                 stats: { executed: 1, failed: 1 },
             },
         ];
-    if (result.passed) {
+    if (result.passed === true) {
         return [{ test, stats: { executed: 1, failed: 0 } }];
     }
     return flattenResults(result, test);

package/build/scope/expect.d.ts

@@ -3,7 +3,7 @@ export declare class Matcher<T> {
     constructor(actual: T);
     get not(): Matcher<T>;
     toBe(expected: T): void;
-    toEqual(expected: T): void;
+    toEqual(expected: T, partial?: boolean): void;
     toMatch(expected: RegExp | string): void;
     toMatchObject(expected: Partial<T>): void;
     toBeNull(): void;

package/build/scope/expect.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { display } from "../display.js";
 import { equals } from "../equal.js";
 export class Matcher {
     actual;
@@ -11,8 +12,8 @@ export class Matcher {
     toBe(expected) {
         assert(this.actual === expected, () => `${this.actual} !== ${expected}`);
     }
-    toEqual(expected) {
-        assert(equals(this.actual, expected), () => `Objects are not equivalent: ${JSON.stringify(this.actual)}, ${JSON.stringify(expected)}`);
+    toEqual(expected, partial = false) {
+        assert(equals(this.actual, expected, partial), () => `Objects are not equivalent: ${display(this.actual)}, ${display(expected)}`);
     }
     toMatch(expected) {
         assert(typeof this.actual === "string", () => "Must have string for regexp match");
@@ -29,7 +30,7 @@ export class Matcher {
         for (const [k, v] of Object.entries(expected)) {
             // @ts-expect-error
             const actual = this.actual[k];
-            assert(equals(actual, v), () => `Comparing ${k}, properties not equal: ${JSON.stringify(actual)}, ${JSON.stringify(v)}`);
+            assert(equals(actual, v, true), () => `Comparing ${k}, properties not equal: ${display(actual)}, ${display(v)}`);
         }
     }
     toBeNull() {

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

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

package/build/server/http/css.js

@@ -0,0 +1,47 @@
+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;
+};

package/build/server/http/index.js

@@ -3,6 +3,7 @@ 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";
@@ -13,6 +14,7 @@ path.join(root, "404.html"), undefined, 404);
 const BASE_MIDDLEWARES = [
     sitemap,
     tsFileServer,
+    cssFileServer,
     staticFileServer,
     findIndex,
     notFound,
@@ -25,8 +27,8 @@ const error = (res, message) => {
     return true;
 };
 const sendContent = async (res, { content, contentType, contentLength }) => {
-    res.setHeader("content-length", `${contentLength}`);
-    res.setHeader("content-type", contentType);
+    res.setHeader("Content-Length", `${contentLength}`);
+    res.setHeader("Content-Type", contentType);
     await res.write(content);
     res.end();
     return true;