@scarletgeek/web-kernel 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 playwithcode-fun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+};

package/dist/KernelEvents.d.ts

@@ -0,0 +1,9 @@
+import { IEventMap, IEventHandler, IUnsubscribeEvent } from "./types/IKernel";
+declare class KernelEvents extends EventTarget {
+    on<K extends keyof IEventMap>(type: K, handler: IEventHandler<IEventMap[K]>, options?: AddEventListenerOptions): IUnsubscribeEvent;
+    once<K extends keyof IEventMap>(type: K, handler: IEventHandler<IEventMap[K]>): void;
+    off<K extends keyof IEventMap>(type: K, handler: IEventHandler<IEventMap[K]>): void;
+    emit<K extends keyof IEventMap>(type: K, detail?: IEventMap[K]): boolean;
+    destroy(): void;
+}
+export default KernelEvents;

package/dist/ProgramHandler.d.ts

@@ -0,0 +1,14 @@
+import { ProgramState } from "./types/IKernel";
+declare class ProgramHandler {
+    private programs;
+    private programState;
+    constructor();
+    isProgramExists(key: string): boolean;
+    addProgram(key: string, program: any): void;
+    startProgram(key: string, args?: any): void;
+    endProgram(key: string): void;
+    getProgramsByState(programState: ProgramState): any;
+    getAllProgramStatus(): any;
+    getProgramStatus(key: string): any;
+}
+export default ProgramHandler;

package/dist/RequestHandler.d.ts

@@ -0,0 +1,7 @@
+import { IKernelRequest } from "./types/IKernel";
+declare class RequestHandler {
+    requests: IKernelRequest;
+    addRequest(key: string, RequestClass: any): void;
+    startRequest(key: string): void;
+}
+export default RequestHandler;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import Kernel from "./kernel";
+import Request from "./request/Request";
+import { LoggerLevel } from "./utils";
+export { Kernel, LoggerLevel, Request };

package/dist/index.js

@@ -0,0 +1 @@
+var t,e,r,s={};function o(t,e,s=void 0){t==r.ERROR?console.error(r.ERROR,e,s):t==r.WARNING?console.warn(r.WARNING,e,s):console.log(r.LOG,e,s)}s.d=(t,e)=>{for(var r in e)s.o(e,r)&&!s.o(t,r)&&Object.defineProperty(t,r,{enumerable:!0,get:e[r]})},s.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),function(t){t.CREATED="CREATED",t.BOOTING="BOOTING",t.BOOTED="BOOTED"}(t||(t={})),function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED",t.ERROR="ERROR"}(e||(e={})),function(t){t.LOG="LOG :: ",t.ERROR="ERROR :: ",t.WARNING="WARNING :: "}(r||(r={}));const n=class{constructor(){this.programs=new Map,this.programState=new Map}isProgramExists(t){return this.programs.has(t)&&this.programState.has(t)}addProgram(t,s){this.programs.has(t)?o(r.WARNING,`Program ${t} already exists.`):(this.programs.set(t,new s),this.programState.set(t,e.IDLE))}startProgram(t,s=null){const n=this.programs.get(t);if(!n)return void o(r.WARNING,`Program ${t} not found.`);if(this.programState.get(t)!==e.RUNNING)if("function"==typeof n.onStart)try{n.onStart(s),this.programState.set(t,e.RUNNING)}catch(s){this.programState.set(t,e.ERROR),o(r.ERROR,`Error occured in program ${t} - `,s)}else o(r.ERROR,`onStart method is not defined in the program ${t}.`);else o(r.WARNING,`Program ${t} is already running.`)}endProgram(t){const s=this.programs.get(t);if(s)if(this.programState.get(t)===e.RUNNING)if("function"==typeof s.onDestroy)try{s.onDestroy(),this.programState.set(t,e.STOPPED)}catch(s){this.programState.set(t,e.ERROR),o(r.ERROR,`Error occured in program ${t} - `,s)}else o(r.ERROR,`onDestroy method is not defined in the program ${t}.`);else o(r.WARNING,`Program ${t} is not running.`);else o(r.WARNING,`Program ${t} not found.`)}getProgramsByState(t){const e={};for(const[r,s]of this.programState)s===t&&(e[r]=s);return e}getAllProgramStatus(){const t={};for(const[e,r]of this.programState)t[e]=r;return t}getProgramStatus(t){return this.programs.get(t)}};class a extends EventTarget{on(t,e,r){return this.addEventListener(t,e,r),()=>this.off(t,e)}once(t,e){this.addEventListener(t,e,{once:!0})}off(t,e){this.removeEventListener(t,e)}emit(t,e={}){return this.dispatchEvent(new CustomEvent(t,{detail:e}))}destroy(){}}const i=a;var h;function c(t){return fetch(t.url,{method:t.method||h.GET,headers:t.headers,body:t.body??null,signal:t.signal})}!function(t){t.GET="GET",t.POST="POST",t.PUT="PUT",t.PATCH="PATCH",t.DELETE="DELETE"}(h||(h={}));const d=class{async transform(t){const e=t.headers.get("content-type")||"";return e.includes("application/json")?await t.json():e.includes("text/")?await t.text():await t.blob()}};class g{constructor(t,e){if(new.target===g)throw new Error("Request is abstract");this.adapter=t??c,this.transformer=e??new d}get method(){return h.GET}get headers(){}get payload(){return null}get signal(){}async send(){try{this.onProcessing();const t=await this.adapter({url:this.url,method:this.method,headers:this.headers,body:this.payload,signal:this.signal});if(!t.ok)throw t;const e=await this.transformer.transform(t);return this.onSuccess(e),e}catch(t){throw this.onError(t),t}}onProcessing(){}onSuccess(t){}onError(t){}}const l=g;const u=class{constructor(){this.requests={}}addRequest(t,e){const r=new e(c);if(!(r instanceof l))throw new Error(`Invalid request "${t}". It must extend kernel Request class.`);this.requests[t]=r}startRequest(t){this.requests[t]||o(r.WARNING,"Request not found."),"function"!=typeof this.requests[t].send&&o(r.ERROR,"Send method not available for the request."),this.requests[t].send()}};const R=class{constructor(){this.programHandler=new n,this.eventHandler=new i,this.requestHandler=new u,this.state=t.CREATED,this.bootHandlers=[]}onBoot(e){this.state!=t.BOOTED?this.bootHandlers.push(e):e(this)}boot(){if(this.state===t.CREATED){this.state=t.BOOTING;for(const t of this.bootHandlers)t(this);this.bootHandlers.length=0,this.state=t.BOOTED}}registerPrograms(t){Object.keys(t).length&&Object.keys(t).forEach(e=>{this.programHandler.addProgram(e,t[e])})}start(t,e=null){this.programHandler.startProgram(t,e)}destroy(t){this.programHandler.endProgram(t)}emit(t,e={}){this.eventHandler.emit(t,e)}on(t,e,r){return this.eventHandler.on(t,e,r)}once(t,e){this.eventHandler.once(t,e)}registerRequests(t){Object.keys(t).length&&Object.keys(t).forEach(e=>{this.requestHandler.addRequest(e,t[e])})}send(t){this.requestHandler.startRequest(t)}status(){const t={};t.programs=this.programHandler.getAllProgramStatus(),console.log(t)}};export{R as Kernel,r as LoggerLevel,l as Request};

package/dist/kernel.d.ts

@@ -0,0 +1,24 @@
+import ProgramHandler from "./ProgramHandler";
+import { IKernelProgram, IEventMap, IEventHandler, IUnsubscribeEvent, IKernelRequest, KernelState } from "./types/IKernel";
+import KernelEvents from "./KernelEvents";
+import RequestHandler from "./RequestHandler";
+declare class Kernel {
+    programHandler: ProgramHandler;
+    eventHandler: KernelEvents;
+    requestHandler: RequestHandler;
+    state: KernelState;
+    bootHandlers: any[];
+    constructor();
+    onBoot(callback: any): void;
+    boot(): void;
+    registerPrograms(programs: IKernelProgram): void;
+    start(programName: string, args?: any): void;
+    destroy(programName: string): void;
+    emit<K extends keyof IEventMap>(type: K, detail?: IEventMap[K]): void;
+    on<K extends keyof IEventMap>(type: K, handler: IEventHandler<IEventMap[K]>, options?: AddEventListenerOptions): IUnsubscribeEvent;
+    once<K extends keyof IEventMap>(type: K, handler: IEventHandler<IEventMap[K]>): void;
+    registerRequests(requests: IKernelRequest): void;
+    send(key: string): void;
+    status(): void;
+}
+export default Kernel;

package/dist/mix-manifest.json

@@ -0,0 +1,3 @@
+{
+    "/index.js": "/index.js"
+}

package/dist/request/DataTransformer.d.ts

@@ -0,0 +1,5 @@
+import { ResponseTransformer } from "./interfaces";
+declare class DataTransformer<T = Response> implements ResponseTransformer<T> {
+    transform(response: Response): Promise<T>;
+}
+export default DataTransformer;

package/dist/request/Request.d.ts

@@ -0,0 +1,16 @@
+import { RequestAdapter, RequestMethods, ResponseTransformer } from "./interfaces";
+declare abstract class Request<T = Response> {
+    protected adapter: RequestAdapter;
+    protected transformer: ResponseTransformer<T>;
+    constructor(adapter?: RequestAdapter, transformer?: ResponseTransformer<T>);
+    protected abstract get url(): string;
+    protected get method(): RequestMethods;
+    protected get headers(): HeadersInit | undefined;
+    protected get payload(): BodyInit | null;
+    protected get signal(): AbortSignal | undefined;
+    send(): Promise<T>;
+    protected onProcessing(): void;
+    protected onSuccess(_response: T): void;
+    protected onError(_error: any): void;
+}
+export default Request;

package/dist/request/adapters.d.ts

@@ -0,0 +1,2 @@
+import { FetchRequestConfig } from "./interfaces";
+export declare function fetchAdapter(config: FetchRequestConfig): Promise<Response>;

package/dist/request/interfaces.d.ts

@@ -0,0 +1,18 @@
+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 declare enum RequestMethods {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}

package/dist/types/IKernel.d.ts

@@ -0,0 +1,27 @@
+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 declare enum KernelState {
+    CREATED = "CREATED",
+    BOOTING = "BOOTING",
+    BOOTED = "BOOTED"
+}
+export declare enum ProgramState {
+    IDLE = "IDLE",
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED",
+    ERROR = "ERROR"
+}
+export interface IKernelProgramInstance {
+    onStart: () => void;
+    onDestroy: () => void;
+}
+export interface IKernelProgramConstructor {
+    new (): IKernelProgramInstance;
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare enum LoggerLevel {
+    LOG = "LOG :: ",
+    ERROR = "ERROR :: ",
+    WARNING = "WARNING :: "
+}
+export declare function logger(level: LoggerLevel, message: any, data?: any): void;