jopijs 0.0.1

package/dist/@core/jopiEasy.d.ts

@@ -0,0 +1,287 @@
+import * as jk_events from "jopi-toolkit/jk_events";
+import type { Config as TailwindConfig } from 'tailwindcss';
+import { type FetchOptions, type ServerFetchOptions } from "./serverFetch.ts";
+import { type LetsEncryptParams, type OnTimeoutError } from "./letsEncrypt.ts";
+import { type UserInfos_WithLoginPassword, UserStore_WithLoginPassword } from "./userStores.ts";
+import { type PostCssInitializer } from "./bundler/config.ts";
+import { type InMemoryCacheOptions } from "./caches/InMemoryCache.ts";
+import { type CrawlerCanIgnoreIfAlreadyCrawled, type UrlProcessedInfos } from "jopijs/crawler";
+import { type FakeNoUserListener, JopiRequest } from "./jopiRequest.ts";
+import { type UserAuthentificationFunction, type CacheRules, type HttpMethod, type JopiMiddleware, type JopiPostMiddleware, type MiddlewareOptions, type UserInfos, type WebSite, WebSiteOptions } from "./jopiWebSite.tsx";
+import { type SseEvent } from "./jopiServer.ts";
+declare class JopiApp {
+    private _isStartAppSet;
+    startApp(importMeta: any, f: (jopiEasy: JopiEasy) => void | Promise<void>): void;
+}
+export declare class JopiEasy {
+    private getDefaultUrl;
+    create_creatWebSiteServer(url?: string, ref?: RefFor_WebSite): JopiEasyWebSite;
+    create_webSiteDownloader(urlOrigin?: string | undefined): CrawlerDownloader;
+}
+export declare class RefFor_WebSite {
+    webSite?: JopiEasyWebSite;
+    waitWebSiteReady(): Promise<void>;
+}
+export declare const jopiApp: JopiApp;
+declare class CrawlerDownloader {
+    private readonly urlOrigin;
+    private readonly _options;
+    private _outputDir;
+    private _startUrl?;
+    private readonly _urlPrefix;
+    private _ignoreIfAlreadyDownloaded?;
+    private _onUrlProcessed?;
+    private _filter_canIgnoreIfAlreadyCrawled?;
+    constructor(urlOrigin: string);
+    /**
+     * Define the directory where files will be downloaded.
+     * If not set, that it takes the current url and the hostname.
+     */
+    set_outputDir(outputDir: string): this;
+    /**
+     * Define the start point url.
+     * If not set, the default is "/".
+     * @param url
+     */
+    set_startUrl(url: string): this;
+    private normalizeUrl;
+    /**
+     * Add url with must be crawled.
+     * Is required if these urls aren't reachable from the start point.
+     */
+    set_extraUrls(urlList: string[]): this;
+    /**
+     * Allow avoiding downloading again a resource if already in cache.
+     * @param value
+     */
+    setOption_ignoreIfAlreadyDownloaded(value?: boolean): this;
+    /**
+     * Set a function which is called when a URL has been processed.
+     *
+     * @param listener - A function that received information about the URL and his processing state.
+     */
+    on_urlProcessed(listener: (infos: UrlProcessedInfos) => void): this;
+    /**
+     * Sets a filter function to determine whether a URL can be downloaded.
+     *
+     * @param filter - A function that takes the URL as a string and a boolean flag
+     *                 indicating if it is a resource, and returns a boolean indicating
+     *                 whether the URL can be downloaded.
+     *
+     *                 Returns true if the url can be processed.
+     */
+    setFilter_canProcessThisUrl(filter: (url: string, isResource: boolean) => boolean): this;
+    setFilter_canIgnoreIfAlreadyDownloaded(filter: (url: string, infos: CrawlerCanIgnoreIfAlreadyCrawled) => boolean): this;
+    START_DOWNLOAD(): Promise<void>;
+}
+declare class CreateServerFetch<T, R extends CreateServerFetch_NextStep<T>> {
+    protected options?: ServerFetchOptions<T>;
+    protected createNextStep(options: ServerFetchOptions<T>): R;
+    /**
+     * The server will be call with his IP and not his hostname
+     * which will only be set in the headers. It's required when
+     * the DNS doesn't pinpoint to the god server.
+     */
+    useIp(serverOrigin: string, ip: string, options?: ServerFetchOptions<T>): R;
+    useOrigin(serverOrigin: string, options?: ServerFetchOptions<T>): R;
+}
+declare class CreateServerFetch_NextStep<T> {
+    protected options: ServerFetchOptions<T>;
+    constructor(options: ServerFetchOptions<T>);
+    set_weight(weight: number): this;
+    set_isMainServer(): this;
+    set_isBackupServer(): this;
+    on_beforeRequesting(handler: (url: string, fetchOptions: FetchOptions, data: T) => void | Promise<void>): this;
+    on_ifServerIsDown(handler: (builder: IfServerDownBuilder<T>) => void | Promise<void>): this;
+    do_startServer(handler: () => Promise<number>): this;
+    do_stopServer(handler: () => Promise<void>): this;
+}
+declare class IfServerDownBuilder<T> extends CreateServerFetch<T, CreateServerFetch_NextStep<T>> {
+    readonly data: T;
+    constructor(data: T);
+    static newBuilder<T>(data: T): {
+        builder: IfServerDownBuilder<T>;
+        getResult: () => ServerFetchOptions<T> | undefined;
+    };
+}
+export interface FileServerOptions {
+    rootDir: string;
+    replaceIndexHtml: boolean;
+    onNotFound: (req: JopiRequest) => Response | Promise<Response>;
+}
+export declare class JopiEasyWebSite {
+    protected readonly origin: string;
+    protected readonly hostName: string;
+    private webSite?;
+    protected readonly options: WebSiteOptions;
+    protected readonly afterHook: ((webSite: WebSite) => (Promise<void>))[];
+    protected readonly beforeHook: (() => Promise<void>)[];
+    protected readonly internals: WebSiteInternal;
+    protected _isWebSiteReady: boolean;
+    protected fileServerOptions: FileServerOptions;
+    readonly events: jk_events.EventGroup;
+    constructor(url: string);
+    private initWebSiteInstance;
+    hook_webSite(hook: (webSite: WebSite) => void): this;
+    DONE_createWebSite(): JopiApp;
+    add_httpCertificate(): CertificateBuilder;
+    fastConfigure_fileServer(options: FileServerOptions): this;
+    configure_fileServer(): {
+        set_rootDir: (rootDir: string) => /*elided*/ any;
+        set_onNotFound: (handler: (req: JopiRequest) => Response | Promise<Response>) => /*elided*/ any;
+        DONE_configure_fileServer: () => JopiEasyWebSite;
+    };
+    configure_jwtTokenAuth(): JWT_BEGIN;
+    fastConfigure_jwtTokenAuth<T>(privateKey: string, store: any[] | UserAuthentificationFunction<T>): JopiEasyWebSite;
+    add_SseEvent(path: string | string[], handler: SseEvent): this;
+    configure_postCss(): {
+        setPlugin: (handler: PostCssInitializer) => /*elided*/ any;
+        END_configure_postCss(): JopiEasyWebSite;
+    };
+    configure_behaviors(): WebSite_ConfigureBehaviors;
+    configure_cache(): WebSite_CacheBuilder;
+    configure_middlewares(): WebSite_MiddlewareBuilder;
+    configure_bundler(): {
+        dontEmbed_ReactJS: () => /*elided*/ any;
+        dontEmbedThis: (...packages: string[]) => /*elided*/ any;
+        END_configure_bundler(): JopiEasyWebSite;
+    };
+    configure_tailwindProcessor(): {
+        disableTailwind: () => /*elided*/ any;
+        setGlobalCssContent: (template: string) => /*elided*/ any;
+        setConfig: (config: TailwindConfig) => /*elided*/ any;
+        /**
+         * Allows adding extra-sources files to scan.
+         * Can also be motifs. Ex: "./myDir/*.{js,ts,jsx,tsx}"
+         */
+        addExtraSourceFiles: (...files: string[]) => /*elided*/ any;
+        setGlobalCssFilePath: (filePath: string) => /*elided*/ any;
+        END_configure_tailwindProcessor(): JopiEasyWebSite;
+    };
+    add_sourceServer<T>(): WebSite_AddSourceServerBuilder<T>;
+    add_specialPageHandler(): WebSite_AddSpecialPageHandler;
+    on_webSiteReady(listener: () => void): this | undefined;
+    configure_cors(): WebSite_ConfigureCors;
+    fastConfigure_cors(allowedHosts?: string[]): JopiEasyWebSite;
+}
+declare class WebSite_ConfigureCors {
+    private readonly webSite;
+    constructor(webSite: JopiEasyWebSite);
+    add_allowedHost(hostName: string): this;
+    disable_cors(): this;
+    DONE_configure_cors(): JopiEasyWebSite;
+}
+declare class WebSite_AddSpecialPageHandler {
+    private readonly webSite;
+    private readonly internals;
+    constructor(webSite: JopiEasyWebSite, internals: WebSiteInternal);
+    END_add_specialPageHandler(): JopiEasyWebSite;
+    on_404_NotFound(handler: (req: JopiRequest) => Promise<Response>): this;
+    on_500_Error(handler: (req: JopiRequest) => Promise<Response>): this;
+    on_401_Unauthorized(handler: (req: JopiRequest) => Promise<Response>): this;
+}
+declare class WebSite_AddSourceServerBuilder<T> extends CreateServerFetch<T, WebSite_AddSourceServerBuilder_NextStep<T>> {
+    private readonly webSite;
+    private readonly internals;
+    private serverFetch?;
+    constructor(webSite: JopiEasyWebSite, internals: WebSiteInternal);
+    protected createNextStep(options: ServerFetchOptions<T>): WebSite_AddSourceServerBuilder_NextStep<T>;
+    END_add_sourceServer(): JopiEasyWebSite;
+    add_sourceServer<T>(): WebSite_AddSourceServerBuilder<T>;
+}
+declare class WebSite_AddSourceServerBuilder_NextStep<T> extends CreateServerFetch_NextStep<T> {
+    private readonly webSite;
+    private readonly internals;
+    constructor(webSite: JopiEasyWebSite, internals: WebSiteInternal, options: ServerFetchOptions<T>);
+    END_add_sourceServer(): JopiEasyWebSite;
+    add_sourceServer<T>(): WebSite_AddSourceServerBuilder<T>;
+}
+declare class WebSite_MiddlewareBuilder {
+    private readonly webSite;
+    private readonly internals;
+    constructor(webSite: JopiEasyWebSite, internals: WebSiteInternal);
+    add_middleware(method: HttpMethod | undefined, middleware: JopiMiddleware, options?: MiddlewareOptions): WebSite_MiddlewareBuilder;
+    add_postMiddleware(method: HttpMethod | undefined, middleware: JopiPostMiddleware, options?: MiddlewareOptions): WebSite_MiddlewareBuilder;
+    END_configure_middlewares(): JopiEasyWebSite;
+}
+declare class WebSite_CacheBuilder {
+    private readonly webSite;
+    private readonly internals;
+    private cache?;
+    private onFakeNoUser?;
+    private readonly rules;
+    constructor(webSite: JopiEasyWebSite, internals: WebSiteInternal);
+    on_fakeNoUser(listener: FakeNoUserListener): WebSite_CacheBuilder;
+    use_inMemoryCache(options?: InMemoryCacheOptions): WebSite_CacheBuilder;
+    use_fileSystemCache(rootDir: string): WebSite_CacheBuilder;
+    add_cacheRules(rules: CacheRules): WebSite_CacheBuilder;
+    END_configure_cache(): JopiEasyWebSite;
+}
+interface WebSite_ConfigureBehaviors {
+    removeTrailingSlashs(value: boolean | undefined): WebSite_ConfigureBehaviors;
+    DONE_configure_behaviors(): JopiEasyWebSite;
+}
+declare class CertificateBuilder {
+    private readonly parent;
+    private readonly internals;
+    constructor(parent: JopiEasyWebSite, internals: WebSiteInternal);
+    generate_localDevCert(saveInDir?: string): {
+        DONE_add_httpCertificate: () => JopiEasyWebSite;
+    };
+    use_dirStore(dirPath: string): {
+        DONE_add_httpCertificate: () => JopiEasyWebSite;
+    };
+    generate_letsEncryptCert(email: string): LetsEncryptCertificateBuilder;
+}
+declare class LetsEncryptCertificateBuilder {
+    private readonly parent;
+    private readonly params;
+    constructor(parent: JopiEasyWebSite, params: LetsEncryptParams);
+    DONE_add_httpCertificate(): JopiEasyWebSite;
+    enable_production(value?: boolean): this;
+    disable_log(): this;
+    set_certificateDir(dirPath: string): this;
+    force_expireAfter_days(dayCount: number): this;
+    force_timout_sec(value: number): this;
+    if_timeOutError(handler: OnTimeoutError): this;
+}
+interface JWT_BEGIN {
+    step_setPrivateKey(privateKey: string): JWT_StepBegin_SetUserStore;
+}
+interface JWT_FINISH {
+    DONE_configure_jwtTokenAuth(): JopiEasyWebSite;
+}
+interface JWT_StepBegin_SetUserStore {
+    step_setUserStore(): JWT_Step_SetUserStore;
+}
+interface JWT_Step_SetUserStore {
+    use_simpleLoginPassword(): JWT_UseSimpleLoginPassword;
+    use_customStore<T>(store: UserAuthentificationFunction<T>): JWT_UseCustomStore;
+}
+interface JWT_UseCustomStore {
+    DONE_use_customStore(): JWT_StepBegin_Configure;
+}
+interface JWT_UseSimpleLoginPassword {
+    getStoreRef(h: GetValue<UserStore_WithLoginPassword>): JWT_UseSimpleLoginPassword;
+    addOne(login: string, password: string, userInfos: UserInfos): JWT_UseSimpleLoginPassword;
+    addMany(users: UserInfos_WithLoginPassword[]): JWT_UseSimpleLoginPassword;
+    DONE_use_simpleLoginPassword(): JWT_StepBegin_Configure;
+}
+interface JWT_StepBegin_Configure {
+    stepConfigure(): JWT_Step_Configure;
+    DONE_setUserStore(): JWT_FINISH;
+}
+interface JWT_Step_Configure {
+    set_cookieDuration(expirationDuration_hours: number): JWT_Step_Configure;
+    DONE_stepConfigure(): JWT_FINISH;
+}
+type GetValue<T> = (value: T) => void;
+interface WebSiteInternal {
+    origin: string;
+    hostName: string;
+    options: WebSiteOptions;
+    afterHook: ((webSite: WebSite) => void | Promise<void>)[];
+    beforeHook: (() => Promise<void>)[];
+    onHookWebSite?: (webSite: WebSite) => void;
+}
+export {};