@scarletgeek/web-kernel 1.0.0

package/src/request/Request.ts

@@ -0,0 +1,70 @@
+import { fetchAdapter } from "./adapters";
+import DataTransformer from "./DataTransformer";
+import { FetchRequestConfig, RequestAdapter, RequestMethods, ResponseTransformer } from "./interfaces";
+
+abstract class Request<T = Response> {
+    protected adapter: RequestAdapter;
+    protected transformer: ResponseTransformer<T>;
+
+    constructor(
+        adapter?: RequestAdapter,
+        transformer?: ResponseTransformer<T>
+    ) {
+        if(new.target === Request) {
+            throw new Error("Request is abstract");
+        }
+        this.adapter = adapter ?? fetchAdapter;
+        this.transformer = transformer ?? new DataTransformer<T>();
+    }
+
+    protected abstract get url(): string;
+
+    protected get method(): RequestMethods {
+        return RequestMethods.GET;
+    }
+
+    protected get headers(): HeadersInit | undefined {
+        return undefined;
+    }
+
+    protected get payload(): BodyInit | null {
+        return null;
+    }
+
+    protected get signal(): AbortSignal | undefined {
+        return undefined;
+    }
+
+    async send(): Promise<T> {
+        try {
+            this.onProcessing();
+
+            const response = await this.adapter({
+                url: this.url,
+                method: this.method,
+                headers: this.headers,
+                body: this.payload,
+                signal: this.signal
+            });
+
+            if(!response.ok) {
+                throw response;
+            }
+
+            const data = await this.transformer.transform(response);
+
+            this.onSuccess(data);
+            return data;
+            
+        } catch(error) {
+            this.onError(error);
+            throw error;
+        }
+    }
+
+    protected onProcessing(): void {}
+    protected onSuccess(_response: T): void {}
+    protected onError(_error: any): void {}
+}
+
+export default Request;

package/src/request/adapters.ts

@@ -0,0 +1,10 @@
+import { FetchRequestConfig, RequestMethods } from "./interfaces";
+
+export function fetchAdapter(config: FetchRequestConfig): Promise<Response> {
+    return fetch(config.url, {
+        method: config.method || RequestMethods.GET,
+        headers: config.headers,
+        body: config.body ?? null,
+        signal: config.signal
+    });
+}

package/src/request/interfaces.ts

@@ -0,0 +1,21 @@
+export interface FetchRequestConfig {
+    url: string
+    method?: string,
+    headers?: HeadersInit
+    body?: BodyInit | null
+    signal?: AbortSignal
+}
+
+export type RequestAdapter = (config: FetchRequestConfig) => Promise<Response>
+
+export interface ResponseTransformer<T = any> {
+    transform(response: Response): Promise<T>
+}
+
+export enum RequestMethods {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}

package/src/types/IKernel.ts

@@ -0,0 +1,35 @@
+export interface IKernelProgram {
+    [key: string]: any
+}
+
+export type IEventMap = Record<string, any>;
+
+export type IEventHandler<T = unknown> = (event: Event) => void;
+
+export type IUnsubscribeEvent = () => void;
+
+export interface IKernelRequest {
+    [key: string]: any
+}
+
+export enum KernelState {
+    CREATED = "CREATED",
+    BOOTING = "BOOTING",
+    BOOTED = "BOOTED"
+}
+
+export enum ProgramState {
+    IDLE = "IDLE",
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED",
+    ERROR = "ERROR"
+}
+
+export interface IKernelProgramInstance {
+    onStart: () => void;
+    onDestroy: () => void;
+}
+
+export interface IKernelProgramConstructor {
+    new () : IKernelProgramInstance;
+}

package/src/utils.ts

@@ -0,0 +1,15 @@
+export enum LoggerLevel {
+    LOG = "LOG :: ",
+    ERROR = "ERROR :: ",
+    WARNING = "WARNING :: "
+}
+
+export function logger(level: LoggerLevel, message: any, data: any = undefined) {
+    if(level == LoggerLevel.ERROR) {
+        console.error(LoggerLevel.ERROR, message, data);
+    } else if(level == LoggerLevel.WARNING) {
+        console.warn(LoggerLevel.WARNING, message, data);
+    } else {
+        console.log(LoggerLevel.LOG, message, data);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}

package/webpack.mix.js

@@ -0,0 +1,14 @@
+const mix = require("laravel-mix");
+
+mix.ts("src/index.ts", "dist/")
+    .setPublicPath("dist")
+       .webpackConfig({
+          output: {
+             library: {
+                type: "module",
+             }
+          },
+          experiments: {
+             outputModule: true
+          }
+       });