jopijs 0.0.1

package/src/@core/caches/cache.ts

@@ -0,0 +1,77 @@
+import {makeIterable} from "../internalTools.js";
+import type {JopiRequest} from "../jopiRequest.tsx";
+
+export interface CacheRole {
+    isUserCache?: boolean;
+    isMobileCache?: boolean;
+}
+
+export interface PageCache {
+    cacheRole?: CacheRole;
+
+    getFromCache(req: JopiRequest, url: URL): Promise<Response | undefined>;
+
+    addToCache(req: JopiRequest, url: URL, response: Response, headersToInclude: string[] | undefined): Promise<Response>;
+
+    hasInCache(url: URL): Promise<boolean>;
+
+    removeFromCache(url: URL): Promise<void>;
+
+    createSubCache(name: string): PageCache;
+
+    getSubCacheIterator(): Iterable<string>;
+
+    getCacheEntryIterator(subCacheName?: string): Iterable<CacheEntry>;
+}
+
+export class VoidPageCache implements PageCache {
+    getFromCache(): Promise<Response | undefined> {
+        return Promise.resolve(undefined);
+    }
+
+    addToCache(_req: JopiRequest, _url: URL, response: Response): Promise<Response> {
+        return Promise.resolve(response);
+    }
+
+    hasInCache(): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+    removeFromCache(_url: URL): Promise<void> {
+        return Promise.resolve();
+    }
+
+    createSubCache(): PageCache {
+        return this;
+    }
+
+    getCacheEntryIterator() {
+        return makeIterable({
+            next(): IteratorResult<CacheEntry> {
+                return { value: undefined, done: true };
+            }
+        });
+    }
+
+    getSubCacheIterator() {
+        return makeIterable({
+            next(): IteratorResult<string> {
+                return { value: undefined, done: true };
+            }
+        });
+    }
+}
+
+export interface CacheEntry {
+    url: string;
+    binary?: Uint8Array<ArrayBuffer>;
+    binarySize?: number;
+    isGzipped?: boolean;
+
+    headers?: {[key:string]: string};
+
+    status?: number;
+
+    _refCount?: number;
+    _refCountSinceGC?: number;
+}

package/src/@core/caches/webSiteMirrorCache.ts

@@ -0,0 +1,90 @@
+import path from "node:path";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import type {JopiRequest} from "../jopiRequest";
+import fs from "node:fs/promises";
+import {makeIterable} from "../internalTools.ts";
+import type {CacheEntry, PageCache} from "./cache.ts";
+
+export class WebSiteMirrorCache implements PageCache {
+    public readonly rootDir: string;
+    public readonly rootDirAtFileUrl: string;
+
+    constructor(rootDir: string) {
+        if (!rootDir) rootDir = ".";
+        if (!path.isAbsolute(rootDir)) rootDir = path.resolve(process.cwd(), rootDir);
+        this.rootDir = rootDir;
+        this.rootDirAtFileUrl = jk_fs.pathToFileURL(this.rootDir).href;
+    }
+
+    private calKey(url: URL): string {
+        let sURL = this.rootDirAtFileUrl + url.pathname;
+        return jk_fs.fileURLToPath(sURL);
+    }
+
+    private calcFilePath(url: URL): string {
+        let fp = this.calKey(url);
+
+        if (fp.endsWith("/")) {
+            fp += "index.html";
+        } else {
+            const ext = path.extname(fp);
+            if (!ext) fp += "/index.html";
+        }
+
+        return fp;
+    }
+
+    async addToCache(req: JopiRequest, url: URL, response: Response): Promise<Response> {
+        // We don't store 404 and others.
+        if (response.status !== 200) return response;
+
+        const filePath = this.calcFilePath(url);
+        await fs.mkdir(path.dirname(filePath), {recursive: true});
+
+        try {
+            if (!response.body) return response;
+            await jk_fs.writeResponseToFile(new Response(response.body), filePath);
+            return await req.file_returnFile(filePath);
+        } catch (e) {
+            console.error(e);
+            return new Response("", {status: 500});
+        }
+    }
+
+    async removeFromCache(url: URL): Promise<void> {
+        const filePath = this.calcFilePath(url);
+        await fs.unlink(filePath);
+    }
+
+    async hasInCache(url: URL): Promise<boolean> {
+        const filePath = this.calcFilePath(url);
+        const stats = await jk_fs.getFileStat(filePath);
+        return !!stats && stats.isFile();
+    }
+
+    getFromCache(req: JopiRequest, url: URL): Promise<Response | undefined> {
+        const filePath = this.calcFilePath(url);
+        return req.file_tryReturnFile(filePath);
+    }
+
+    createSubCache(name: string): PageCache {
+        const newDir = path.join(this.rootDir, "_ subCaches", name);
+        return new WebSiteMirrorCache(newDir);
+    }
+
+    getCacheEntryIterator() {
+        return makeIterable({
+            next(): IteratorResult<CacheEntry> {
+                return {value: undefined, done: true};
+            }
+        });
+    }
+
+    getSubCacheIterator() {
+        return makeIterable({
+            next(): IteratorResult<string> {
+                return {value: undefined, done: true};
+            }
+        });
+    }
+}

package/src/@core/cheerio.d.ts

@@ -0,0 +1,332 @@
+/// <reference types="node" />
+
+// -- JOPI (Johan P) --
+//
+// It's comme from the original type definition of cheerio where I have added
+// - reactReplaceWith
+// - reactReplaceContentWith
+
+
+interface Document {}
+
+declare namespace cheerio {
+    type Element = TextElement | TagElement | CommentElement;
+
+    interface TextElement {
+        type: "text";
+        next: Element | null;
+        prev: Element | null;
+        parent: Element;
+        data?: string | undefined;
+        startIndex?: number | undefined;
+        endIndex?: number | undefined;
+        attribs: { [attr: string]: string };
+    }
+
+    interface TagElement {
+        tagName: string;
+        type: "tag" | "script" | "style";
+        name: string;
+        attribs: { [attr: string]: string };
+        "x-attribsNamespace": { [attr: string]: string };
+        "x-prefixNamespace": { [attr: string]: string };
+        children: Element[];
+        childNodes: Element[] | null;
+        lastChild: Element | null;
+        firstChild: Element | null;
+        next: Element | null;
+        nextSibling: Element;
+        prev: Element | null;
+        previousSibling: Element;
+        parent: Element;
+        parentNode: Element;
+        nodeValue: string;
+        data?: string | undefined;
+        startIndex?: number | undefined;
+        endIndex?: number | undefined;
+    }
+
+    interface CommentElement {
+        type: "comment";
+        next: Element | null;
+        prev: Element | null;
+        parent: Element;
+        data?: string | undefined;
+        startIndex?: number | undefined;
+        endIndex?: number | undefined;
+        attribs: { [attr: string]: string };
+    }
+
+    type AttrFunction = (el: Element, i: number, currentValue: string) => any;
+
+    interface Cheerio {
+        // >>> JOPI HACK
+        reactReplaceWith(node: React.ReactNode): Cheerio;
+        reactReplaceContentWith(node: React.ReactNode): Cheerio;
+        // <<< JOPI HACK
+
+        // Document References
+        // Cheerio https://github.com/cheeriojs/cheerio
+        // JQuery http://api.jquery.com
+
+        [Symbol.iterator](): IterableIterator<Element>;
+        [index: number]: Element;
+        cheerio: string;
+        length: number;
+
+        // Attributes
+
+        attr(): { [attr: string]: string };
+        attr(name: string): string | undefined;
+        attr(name: string, value: AttrFunction): Cheerio;
+        // `value` *can* be `any` here but:
+        // 1. That makes type-checking the function-type useless
+        // 2. It's converted to a string anyway
+        attr(name: string, value: string): Cheerio;
+        // The map's values *can* be `any` but they'll all be cast to strings
+        // regardless.
+        attr(map: { [key: string]: any }): Cheerio;
+
+        data(): any;
+        data(name: string): any;
+        data(name: string, value: any): any;
+
+        val(): string;
+        val(value: string): Cheerio;
+
+        removeAttr(name: string): Cheerio;
+
+        has(selector: string): Cheerio;
+        has(element: Element): Cheerio;
+
+        hasClass(className: string): boolean;
+        addClass(classNames: string): Cheerio;
+
+        removeClass(): Cheerio;
+        removeClass(className: string): Cheerio;
+        removeClass(func: (index: number, className: string) => string): Cheerio;
+
+        toggleClass(className: string): Cheerio;
+        toggleClass(className: string, toggleSwitch: boolean): Cheerio;
+        toggleClass(toggleSwitch?: boolean): Cheerio;
+        toggleClass(
+            func: (index: number, className: string, toggleSwitch: boolean) => string,
+            toggleSwitch?: boolean,
+        ): Cheerio;
+
+        is(selector: string): boolean;
+        is(element: Element): boolean;
+        is(element: Element[]): boolean;
+        is(selection: Cheerio): boolean;
+        is(func: (index: number, element: Element) => boolean): boolean;
+
+        // Form
+        serialize(): string;
+        serializeArray(): Array<{ name: string; value: string }>;
+
+        // Traversing
+
+        find(selector: string): Cheerio;
+        find(element: Cheerio): Cheerio;
+
+        parent(selector?: string): Cheerio;
+        parents(selector?: string): Cheerio;
+        parentsUntil(selector?: string, filter?: string): Cheerio;
+        parentsUntil(element: Element, filter?: string): Cheerio;
+        parentsUntil(element: Cheerio, filter?: string): Cheerio;
+
+        prop(name: string): any;
+        prop(name: string, value: any): Cheerio;
+
+        closest(): Cheerio;
+        closest(selector: string): Cheerio;
+
+        next(selector?: string): Cheerio;
+        nextAll(): Cheerio;
+        nextAll(selector: string): Cheerio;
+
+        nextUntil(selector?: string, filter?: string): Cheerio;
+        nextUntil(element: Element, filter?: string): Cheerio;
+        nextUntil(element: Cheerio, filter?: string): Cheerio;
+
+        prev(selector?: string): Cheerio;
+        prevAll(): Cheerio;
+        prevAll(selector: string): Cheerio;
+
+        prevUntil(selector?: string, filter?: string): Cheerio;
+        prevUntil(element: Element, filter?: string): Cheerio;
+        prevUntil(element: Cheerio, filter?: string): Cheerio;
+
+        slice(start: number, end?: number): Cheerio;
+
+        siblings(selector?: string): Cheerio;
+
+        children(selector?: string): Cheerio;
+
+        contents(): Cheerio;
+
+        each(func: (index: number, element: Element) => any): Cheerio;
+        map(func: (index: number, element: Element) => any): Cheerio;
+
+        filter(selector: string): Cheerio;
+        filter(selection: Cheerio): Cheerio;
+        filter(element: Element): Cheerio;
+        filter(elements: Element[]): Cheerio;
+        filter(func: (index: number, element: Element) => boolean): Cheerio;
+
+        not(selector: string): Cheerio;
+        not(selection: Cheerio): Cheerio;
+        not(element: Element): Cheerio;
+        not(func: (index: number, element: Element) => boolean): Cheerio;
+
+        first(): Cheerio;
+        last(): Cheerio;
+
+        eq(index: number): Cheerio;
+
+        get(): any[];
+        get(index: number): any;
+
+        index(): number;
+        index(selector: string): number;
+        index(selection: Cheerio): number;
+
+        end(): Cheerio;
+
+        add(selectorOrHtml: string): Cheerio;
+        add(selector: string, context: Document): Cheerio;
+        add(element: Element): Cheerio;
+        add(elements: Element[]): Cheerio;
+        add(selection: Cheerio): Cheerio;
+
+        addBack(): Cheerio;
+        addBack(filter: string): Cheerio;
+
+        // Manipulation
+        appendTo(target: Cheerio): Cheerio;
+        prependTo(target: Cheerio): Cheerio;
+
+        append(content: string, ...contents: any[]): Cheerio;
+        append(content: Document, ...contents: any[]): Cheerio;
+        append(content: Document[], ...contents: any[]): Cheerio;
+        append(content: Cheerio, ...contents: any[]): Cheerio;
+
+        prepend(content: string, ...contents: any[]): Cheerio;
+        prepend(content: Document, ...contents: any[]): Cheerio;
+        prepend(content: Document[], ...contents: any[]): Cheerio;
+        prepend(content: Cheerio, ...contents: any[]): Cheerio;
+
+        after(content: string, ...contents: any[]): Cheerio;
+        after(content: Document, ...contents: any[]): Cheerio;
+        after(content: Document[], ...contents: any[]): Cheerio;
+        after(content: Cheerio, ...contents: any[]): Cheerio;
+
+        insertAfter(content: string): Cheerio;
+        insertAfter(content: Document): Cheerio;
+        insertAfter(content: Cheerio): Cheerio;
+
+        before(content: string, ...contents: any[]): Cheerio;
+        before(content: Document, ...contents: any[]): Cheerio;
+        before(content: Document[], ...contents: any[]): Cheerio;
+        before(content: Cheerio, ...contents: any[]): Cheerio;
+
+        insertBefore(content: string): Cheerio;
+        insertBefore(content: Document): Cheerio;
+        insertBefore(content: Cheerio): Cheerio;
+
+        remove(selector?: string): Cheerio;
+
+        replaceWith(content: string): Cheerio;
+        replaceWith(content: Element): Cheerio;
+        replaceWith(content: Element[]): Cheerio;
+        replaceWith(content: Cheerio): Cheerio;
+        replaceWith(content: () => Cheerio): Cheerio;
+
+        empty(): Cheerio;
+
+        html(): string | null;
+        html(html: string): Cheerio;
+
+        text(): string;
+        text(text: string): Cheerio;
+
+        wrap(content: string): Cheerio;
+        wrap(content: Document): Cheerio;
+        wrap(content: Cheerio): Cheerio;
+
+        css(propertyName?: string): string;
+        css(propertyNames: string[]): string[];
+        css(propertyName: string, value: string): Cheerio;
+        css(propertyName: string, value: number): Cheerio;
+        css(propertyName: string, func: (index: number, value: string) => string): Cheerio;
+        css(propertyName: string, func: (index: number, value: string) => number): Cheerio;
+        css(properties: Object): Cheerio;
+
+        // Rendering
+
+        // Miscellaneous
+
+        clone(): Cheerio;
+
+        // Not Documented
+
+        toArray(): Element[];
+    }
+
+    interface CheerioParserOptions {
+        // Document References
+        // Cheerio https://github.com/cheeriojs/cheerio
+        // HTMLParser2 https://github.com/fb55/htmlparser2/wiki/Parser-options
+        // DomHandler https://github.com/fb55/DomHandler
+
+        xmlMode?: boolean | undefined;
+        decodeEntities?: boolean | undefined;
+        lowerCaseTags?: boolean | undefined;
+        lowerCaseAttributeNames?: boolean | undefined;
+        recognizeCDATA?: boolean | undefined;
+        recognizeSelfClosing?: boolean | undefined;
+        normalizeWhitespace?: boolean | undefined;
+        withStartIndices?: boolean | undefined;
+        withEndIndices?: boolean | undefined;
+        ignoreWhitespace?: boolean | undefined;
+        _useHtmlParser2?: boolean | undefined;
+    }
+
+    interface Selector {
+        (selector: string): Cheerio;
+        (selector: string, context: string): Cheerio;
+        (selector: string, context: Element): Cheerio;
+        (selector: string, context: Element[]): Cheerio;
+        (selector: string, context: Cheerio): Cheerio;
+        (selector: string, context: string, root: string): Cheerio;
+        (selector: string, context: Element, root: string): Cheerio;
+        (selector: string, context: Element[], root: string): Cheerio;
+        (selector: string, context: Cheerio, root: string): Cheerio;
+        (selector: any): Cheerio;
+    }
+
+    interface Root extends Selector {
+        // Document References
+        // Cheerio https://github.com/cheeriojs/cheerio
+        // JQuery http://api.jquery.com
+        root(): Cheerio;
+        contains(container: Element, contained: Element): boolean;
+        parseHTML(data: string, context?: Document | null, keepScripts?: boolean): Document[];
+
+        html(options?: CheerioParserOptions): string;
+        html(dom: string | Cheerio | Element, options?: CheerioParserOptions): string;
+
+        xml(dom?: string | Cheerio | Element): string;
+    }
+
+    interface CheerioAPI extends Root {
+        version: string;
+        load(html: string | Buffer, options?: CheerioParserOptions): Root;
+        load(element: Element | Element[], options?: CheerioParserOptions): Root;
+    }
+}
+
+declare module "cheerio" {
+    const cheerioModule: cheerio.CheerioAPI;
+    export = cheerioModule;
+}

package/src/@core/gzip.ts

@@ -0,0 +1,33 @@
+// noinspection JSUnusedGlobalSymbols
+
+import {pipeline} from "node:stream/promises";
+import {createReadStream, createWriteStream} from "node:fs";
+import {createGunzip, createGzip} from "node:zlib";
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import * as jk_fs from "jopi-toolkit/jk_fs";
+
+export async function gzipFile(inputPath: string, outputPath: string) {
+    try {
+        await pipeline(createReadStream(inputPath), createGzip(), createWriteStream(outputPath));
+    } catch (e) {
+        console.error("Can't gzip file", inputPath, e);
+    }
+}
+
+export async function gunzipFile(inputPath: string, outputPath: string) {
+    try {
+        await pipeline(createReadStream(inputPath), createGunzip(), createWriteStream(outputPath));
+    } catch (e) {
+        console.error("Can't gunzip file", inputPath, e);
+    }
+}
+
+export async function mkDirForFile(filePath: string): Promise<void> {
+    const directoryPath = path.dirname(filePath);
+    await fs.mkdir(directoryPath, {recursive: true});
+}
+
+export async function saveReadableStreamToFile(filePath: string, stream: ReadableStream<Uint8Array>) {
+    await jk_fs.writeResponseToFile(new Response(stream), filePath);
+}

package/src/@core/index.ts

@@ -0,0 +1,23 @@
+export * from "./publicTools.ts";
+export * from "./searchParamFilter.ts";
+export * from "./serverFetch.ts";
+export * from "./caches/InMemoryCache.ts";
+export * from "./caches/SimpleFileCache.ts";
+export * from "./loadBalancing.ts";
+export * from "./automaticStartStop.ts";
+export * from "./middlewares/index.ts";
+
+export * from "./letsEncrypt.ts";
+export * from "./jopiEasy.ts";
+export * from "./routeConfig.ts";
+
+export * from "./jopiRequest.tsx";
+export * from "./jopiWebSite.tsx";
+export * from "./jopiServer.ts";
+export * from "./browserCacheControl.ts";
+
+export * from "./bundler/config.ts";
+
+
+export {type CreateBundleParams} from "./bundler/bundler.ts";
+export {type BundlerConfig} from "./bundler/config.ts";

package/src/@core/internalTools.ts

@@ -0,0 +1,95 @@
+import type {CacheEntry} from "./caches/cache.ts";
+import * as jk_timer from "jopi-toolkit/jk_timer";
+
+export const serverInitChronos = jk_timer.chrono(false);
+
+export function parseCookies(headers: Headers): { [name: string]: string } {
+    const cookies: { [name: string]: string } = {};
+    const cookieHeader = headers.get('Cookie');
+
+    if (!cookieHeader) {
+        return cookies;
+    }
+
+    cookieHeader.split(';').forEach(cookie => {
+        const parts = cookie.split('=');
+        if (parts.length >= 2) {
+            const name = parts[0].trim();
+            cookies[name] = parts.slice(1).join('=').trim();
+        }
+    });
+
+    return cookies;
+}
+
+export function readContentLength(headers: Headers): number {
+    const cl = headers.get("content-length");
+    if (!cl) return -1;
+    return parseInt(cl);
+}
+
+const gDefaultHeadersToCache: string[] = [ "content-type", "etag", "last-modified"];
+
+export function cacheAddBrowserCacheValues(cacheEntry: CacheEntry, etag: string) {
+    if (!cacheEntry.headers) cacheEntry.headers = {};
+    cacheEntry.headers["etag"] = etag;
+    cacheEntry.headers["last-modified-since"] = new Date().toUTCString();
+}
+
+export function cacheEntryToResponse(entry: CacheEntry) {
+    if (entry.binary) {
+        let headers = entry.headers;
+        if (!headers) headers = {};
+
+        if (entry.isGzipped) {
+            headers["content-encoding"] = "gzip";
+        }
+        else {
+            delete(headers["content-encoding"]);
+        }
+
+        return new Response(entry.binary.buffer, {
+            status: entry.status ?? 200,
+            headers: headers
+        });
+    }
+
+    return new Response("", {status: entry.status, headers: entry.headers});
+}
+
+export function responseToCacheEntry(url: string, response: Response, headersToInclude: string[]|undefined): CacheEntry {
+    const status = response.status;
+    const entry: CacheEntry = {status, url};
+
+    if (status===200) {
+        const headers = {};
+        entry.headers = headers;
+
+        // "content-type", "etag", "last-modified"
+        if (!headersToInclude) {
+            headersToInclude = gDefaultHeadersToCache;
+        }
+
+        headersToInclude.forEach(header => addHeaderIfExist(headers, header, response.headers));
+    }
+
+    if ((status>=300)&&(status<400)) {
+        entry.headers = {};
+        addHeaderIfExist(entry.headers!, "Location", response.headers);
+    }
+
+    return entry;
+}
+
+export function addHeaderIfExist(headers: {[key: string]: string}, headerName: string, source: Headers) {
+    const v = source.get(headerName);
+    if (v!==null) headers[headerName] = v;
+}
+
+export function makeIterable<T>(iterator: Iterator<T>): Iterable<T> {
+    return {
+        [Symbol.iterator]() {
+            return iterator;
+        }
+    };
+}

package/src/@core/jQuery.ts

@@ -0,0 +1,22 @@
+/// <reference path="cheerio.d.ts" />
+
+import * as ReactServer from 'react-dom/server';
+
+/**
+ * Add our own function to cheerio.
+ * Note: the definition type has directly been added to cheerio.d.ts.
+ */
+export function initCheerio($: cheerio.Root) {
+    $.prototype.reactReplaceWith = function (this: cheerio.Cheerio, node: React.ReactElement): cheerio.Cheerio {
+        // Note: "this: cheerio.Cheerio" allows casting the value of this.
+
+        this.replaceWith(ReactServer.renderToStaticMarkup(node));
+        return this;
+    };
+
+    $.prototype.reactReplaceContentWith = function (this: cheerio.Cheerio, node: React.ReactElement): cheerio.Cheerio {
+        // Note: "this: cheerio.Cheerio" allows casting the value of this.
+
+        return this.html(ReactServer.renderToStaticMarkup(node));
+    };
+}