build: update tsconfig and package.json

CHANGELOG.md

@@ -1,5 +1,3 @@
-
-
 ## [8.0.1](https://github.com/Masquerade-Circus/valyrian.js/compare/8.0.0...8.0.1) (2024-12-11)
 
 ### Styles

dist/lib/flux-store/index.d.ts

@@ -0,0 +1,32 @@
+interface StoreOptions {
+    state?: Record<string, any> | (() => Record<string, any>);
+    mutations?: Record<string, (state: Record<string, any>, ...args: any[]) => void>;
+    actions?: Record<string, (store: FluxStore, ...args: any[]) => any>;
+    getters?: Record<string, (state: Record<string, any>, getters: Record<string, any>, globalState?: any, globalGetters?: any) => any>;
+    modules?: Record<string, StoreOptions>;
+    shouldFreeze?: boolean;
+    namespace?: string;
+    rootStore?: FluxStore;
+}
+export declare class FluxStore {
+    state: Record<string, any>;
+    getters: Record<string, any>;
+    private init;
+    rootStore: FluxStore | null;
+    namespace: string | null;
+    constructor({ state, mutations, actions, getters, modules, shouldFreeze, namespace, rootStore }?: StoreOptions);
+    private keyExists;
+    private isFunction;
+    private getStore;
+    private isUnfrozen;
+    commit(mutation: string, ...args: any[]): void;
+    dispatch(action: string, ...args: any[]): Promise<any>;
+    trigger(event: string, ...args: any[]): void;
+    on(event: string, listener: Function, namespace?: string): () => void;
+    off(event: string, listener: Function): void;
+    use(plugin: Function, ...options: any[]): void;
+    registerModule(namespace: string, module: StoreOptions): void;
+    unregisterModule(namespace: string): void;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

dist/lib/hooks/index.d.ts

@@ -0,0 +1,18 @@
+export type Hook = any;
+export interface HookDefinition {
+    onCreate: (...args: any[]) => any;
+    onUpdate?: (hook: Hook, ...args: any[]) => any;
+    onCleanup?: (hook: Hook) => any;
+    onRemove?: (hook: Hook) => any;
+    returnValue?: (hook: Hook) => any;
+}
+export interface CreateHook {
+    (HookDefinition: HookDefinition): (...args: any[]) => any;
+}
+export declare const createHook: CreateHook;
+export declare const useState: (...args: any[]) => any;
+export declare const useEffect: (...args: any[]) => any;
+export declare const useRef: (...args: any[]) => any;
+export declare const useCallback: (...args: any[]) => any;
+export declare const useMemo: (...args: any[]) => any;
+//# sourceMappingURL=index.d.ts.map

dist/lib/index.d.ts

@@ -0,0 +1,78 @@
+declare global {
+    var document: Document;
+    namespace JSX {
+        interface IntrinsicElements extends DefaultRecord {
+        }
+        type Element = ReturnType<typeof v | ((...args: any) => string | number | null | undefined | boolean | Promise<any>)>;
+        type ComponentReturnType = string | number | null | undefined | boolean | Element | Element[];
+    }
+}
+interface DefaultRecord extends Record<string | number | symbol, any> {
+}
+export interface Properties extends DefaultRecord {
+    key?: string | number;
+}
+export interface DomElement extends Element, DefaultRecord {
+}
+export interface Component extends DefaultRecord {
+    (props: Properties, children: any[]): Vnode | any;
+}
+export interface POJOComponent extends DefaultRecord {
+    view: Component;
+}
+export type ValyrianComponent = Component | POJOComponent;
+export interface VnodeComponentInterface extends Vnode {
+    tag: ValyrianComponent;
+}
+export interface Children extends Array<Vnode | VnodeComponentInterface | ValyrianComponent | any> {
+}
+export interface Directive {
+    (value: any, vnode: VnodeWithDom, oldProps: Properties | null): false | void | any;
+}
+export declare const isNodeJs: boolean;
+export declare class Vnode {
+    tag: string | Component | POJOComponent;
+    props: null | Properties;
+    children: Children;
+    dom?: DomElement | undefined;
+    isSVG?: boolean | undefined;
+    constructor(tag: string | Component | POJOComponent, props: null | Properties, children: Children, dom?: DomElement | undefined, isSVG?: boolean | undefined);
+}
+export interface VnodeWithDom extends Vnode {
+    tag: string;
+    dom: DomElement;
+    props: Properties;
+}
+export declare const isPOJOComponent: (component: unknown) => component is POJOComponent;
+export declare const isComponent: (component: unknown) => component is Component;
+export declare const isVnode: (object?: unknown) => object is Vnode;
+export declare const isVnodeComponent: (object?: unknown) => object is VnodeComponentInterface;
+export declare function v(tagOrComponent: string | ValyrianComponent, props: Properties | null, ...children: Children): Vnode;
+export declare namespace v {
+    var fragment: (_: Properties, ...children: Children) => Children;
+}
+export declare function hidrateDomToVnode(dom: any): VnodeWithDom | void;
+export declare function trust(htmlString: string): (void | VnodeWithDom)[];
+export declare const current: {
+    vnode: Vnode | null;
+    component: ValyrianComponent | null;
+    event: Event | null;
+};
+export declare const reservedProps: Set<string>;
+export declare const onMount: (callback: Function) => false | Set<Function>;
+export declare const onUpdate: (callback: Function) => Set<Function>;
+export declare const onCleanup: (callback: Function) => Set<Function>;
+export declare const onUnmount: (callback: Function) => false | Set<Function>;
+export declare const directives: Record<string, Directive>;
+export declare function directive(name: string, directive: Directive): void;
+export declare function setPropNameReserved(name: string): void;
+export declare function setAttribute(name: string, value: any, newVnode: VnodeWithDom): void;
+export declare function updateAttributes(newVnode: VnodeWithDom, oldProps: Properties | null): void;
+export declare function createElement(tag: string, isSVG: boolean): DomElement;
+export declare function updateVnode(vnode: VnodeWithDom): string | void;
+export declare function update(): string;
+export declare function debouncedUpdate(): void;
+export declare function unmount(): string;
+export declare function mount(dom: string | DomElement, component: ValyrianComponent | VnodeComponentInterface | any): string;
+export {};
+//# sourceMappingURL=index.d.ts.map

dist/lib/native-store/index.d.ts

@@ -0,0 +1,14 @@
+export declare enum StorageType {
+    Session = "session",
+    Local = "local"
+}
+export interface NativeStorageInterface {
+    state: Record<string, any>;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    delete(key: string): void;
+    load(): void;
+    clear(): void;
+}
+export declare function createNativeStore<T>(key: string, definition?: Record<string, any>, storageType?: StorageType, reuseIfExist?: boolean): NativeStorageInterface & T;
+//# sourceMappingURL=index.d.ts.map

dist/lib/node/index.d.ts

@@ -0,0 +1,7 @@
+import { domToHtml, domToHyperscript, htmlToDom, htmlToHyperscript } from "./utils/tree-adapter";
+import { icons } from "./utils/icons";
+import { inline } from "./utils/inline";
+import { sw } from "./utils/sw";
+declare function render(...args: any[]): string;
+export { domToHtml, domToHyperscript, htmlToDom, htmlToHyperscript, inline, sw, icons, render };
+//# sourceMappingURL=index.d.ts.map

dist/lib/node/utils/icons.d.ts

@@ -0,0 +1,33 @@
+export interface IconsOptions {
+    iconsPath: string | null;
+    linksViewPath: string | null;
+    logging: boolean;
+    path: string;
+    appName?: string;
+    appDescription?: string;
+    developerName?: string;
+    developerURL?: string;
+    dir?: "auto" | "ltr" | "rtl" | string;
+    lang?: string;
+    background?: string;
+    theme_color?: string;
+    display?: "browser" | "standalone" | string;
+    orientation?: "any" | "portrait" | "landscape" | string;
+    start_url?: string;
+    version?: string;
+    icons: {
+        android: boolean;
+        appleIcon: boolean;
+        appleStartup: boolean;
+        coast: boolean;
+        favicons: boolean;
+        firefox: boolean;
+        windows: boolean;
+        yandex: boolean;
+    };
+}
+export declare function icons(source: string, configuration?: IconsOptions): Promise<void>;
+export declare namespace icons {
+    var options: IconsOptions;
+}
+//# sourceMappingURL=icons.d.ts.map

dist/lib/node/utils/inline.d.ts

@@ -0,0 +1,13 @@
+export declare function inline(file: string | {
+    raw: string;
+    map?: string | null;
+    file: string;
+}, options?: Record<string, any>): Promise<{
+    raw: string;
+    map: string | null;
+    file: string;
+}>;
+export declare namespace inline {
+    var uncss: (renderedHtml: (string | Promise<string>)[], css: string, options?: Record<string, any>) => Promise<string>;
+}
+//# sourceMappingURL=inline.d.ts.map

dist/lib/node/utils/session-storage.d.ts

@@ -0,0 +1,22 @@
+export declare class SessionStorage {
+    private storage;
+    private limit;
+    private persist;
+    private filePath;
+    private directory;
+    constructor({ persist, filePath }?: {
+        persist?: boolean;
+        filePath?: string;
+    });
+    private getStorageSize;
+    private checkSizeLimit;
+    setItem(key: string | null | undefined, value: string | null | undefined): void;
+    getItem(key: string | null | undefined): string | null;
+    removeItem(key: string | null | undefined): void;
+    clear(): void;
+    get length(): number;
+    key(index: number): string | null;
+    private saveToFile;
+    private loadFromFile;
+}
+//# sourceMappingURL=session-storage.d.ts.map

dist/lib/node/utils/sw.d.ts

@@ -0,0 +1,2 @@
+export declare function sw(file: string, options?: {}): void;
+//# sourceMappingURL=sw.d.ts.map

dist/lib/node/utils/tree-adapter.d.ts

@@ -0,0 +1,80 @@
+interface ChildNodes extends Array<Node | Element | Text | DocumentFragment> {
+}
+export declare class Node implements Node {
+    #private;
+    childNodes: ChildNodes;
+    baseURI: string;
+    tag_name: string;
+    get nodeName(): string;
+    set nodeName(name: string);
+    get tagName(): string;
+    set tagName(name: string);
+    node_type: number;
+    get nodeType(): number;
+    set nodeType(type: number);
+    node_value: string;
+    attributes: Attr[];
+    set textContent(text: string);
+    get textContent(): string;
+    set nodeValue(text: string);
+    get nodeValue(): string;
+    parent_node: Node | null;
+    get parentNode(): Node | null;
+    set parentNode(node: Node | null);
+    get dataset(): Record<string | number, any>;
+    set dataset(value: Record<string | number, any>);
+    constructor();
+    appendChild<T extends Node>(node: T): T;
+    insertBefore<T extends Node>(node: T, child: Node | null): T;
+    replaceChild<T extends Node>(node: Node, child: T): T;
+    removeChild<T extends Node>(child: T): T;
+    remove(): Node;
+    cloneNode(deep?: boolean | undefined): Node;
+    setAttribute(name: string, value: any): void;
+    getAttribute(name: string): string | null | undefined;
+    removeAttribute(name: string): void;
+    getElementById(id: string): Node | null;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
+}
+export declare class Text extends Node {
+    constructor(text: any);
+}
+export declare class Element extends Node {
+    constructor();
+    _style: Record<string, any>;
+    get style(): string;
+    set style(value: string);
+    get className(): string;
+    set className(value: string | boolean);
+    classList: {
+        toggle: (item: any, force: any) => void;
+    };
+    get id(): string;
+    set id(value: string | boolean);
+    set textContent(text: string);
+    get textContent(): string;
+    set innerText(text: string);
+    get innerText(): string;
+    get innerHTML(): string;
+    set innerHTML(html: string);
+    get outerHTML(): string;
+}
+export declare class DocumentFragment extends Element {
+    constructor();
+}
+export declare class Document extends Element {
+    constructor();
+    body: Element;
+    createDocumentFragment(): DocumentFragment;
+    createElement(type: string): Element;
+    createElementNS(ns: string, type: string): Element;
+    createTextNode(text: any): Text;
+}
+export declare function domToHtml(dom: Element | Text | DocumentFragment): string;
+export declare function domToHyperscript(childNodes: ChildNodes, depth?: number): string;
+export declare function htmlToDom(html: string): Element | Text | DocumentFragment;
+export declare function htmlToHyperscript(html: string): string;
+export declare const document: Document;
+export {};
+//# sourceMappingURL=tree-adapter.d.ts.map

dist/lib/pulse-store/index.d.ts

@@ -0,0 +1,16 @@
+type State = Record<string, any>;
+export type Pulse<StateType> = (state: StateType, ...args: any[]) => void | Promise<void>;
+export type Pulses<StateType> = {
+    [key: string]: Pulse<StateType>;
+};
+type ProxyState<StateType> = StateType & {
+    [key: string]: any;
+};
+type StorePulses<PulsesType> = {
+    [K in keyof PulsesType]: PulsesType[K] extends (state: any, ...args: infer Args) => infer R ? (...args: Args) => R : never;
+};
+export declare function createPulseStore<StateType extends State, PulsesType extends Pulses<StateType>>(initialState: StateType, pulses: PulsesType): () => [ProxyState<StateType>, StorePulses<PulsesType>];
+export declare function createMutableStore<StateType extends State, PulsesType extends Pulses<StateType>>(initialState: StateType, pulses: PulsesType): () => [ProxyState<StateType>, StorePulses<PulsesType>];
+export declare function createEffect(effect: Function): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

dist/lib/request/index.d.ts

@@ -0,0 +1,37 @@
+interface UrlOptions {
+    base?: string;
+    node?: string | null;
+    api?: string | null;
+}
+interface RequestOptions {
+    allowedMethods?: string[];
+    urls?: UrlOptions;
+    [key: string | number | symbol]: any;
+}
+interface RequestOptionsWithUrls extends RequestOptions {
+    urls: UrlOptions;
+    allowedMethods: string[];
+}
+interface SendOptions extends RequestOptionsWithUrls, RequestInit {
+    allowedMethods: string[];
+    method: string;
+    headers: Record<string, string>;
+    resolveWithFullResponse?: boolean;
+}
+export interface RequestInterface {
+    (method: string, url: string, data?: Record<string, any> | null, options?: Partial<SendOptions>): any | Response;
+    new: (baseUrl: string, options?: RequestOptions) => RequestInterface;
+    setOptions: (key: string, value: any) => void;
+    getOptions: (key?: string) => RequestOptions | void;
+    get: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    post: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    put: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    patch: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    delete: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    head: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    options: (url: string, data?: Record<string, any> | null, options?: Record<string, any>) => any | Response;
+    [key: string | number | symbol]: any;
+}
+export declare const request: RequestInterface;
+export {};
+//# sourceMappingURL=index.d.ts.map

dist/lib/router/index.d.ts

@@ -0,0 +1,60 @@
+import { Component, POJOComponent, VnodeComponentInterface } from "valyrian.js";
+export interface Request {
+    params: Record<string, any>;
+    query: Record<string, any>;
+    url: string;
+    path: string;
+    matches: string[];
+    redirect: (path: string) => Promise<string | void>;
+}
+export interface Middleware {
+    (req: Request, err?: any): Promise<any | Component | POJOComponent | VnodeComponentInterface> | any | Component | POJOComponent | VnodeComponentInterface;
+}
+export declare const RouterError: {
+    new (message?: string): {
+        status: number | undefined;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    new (message?: string, options?: ErrorOptions): {
+        status: number | undefined;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+type RouteParams = string | Middleware | Router | (string | Middleware | Router | RouteParams)[];
+export declare class Router {
+    private routeTree;
+    container: Element | string | null;
+    query: Record<string, string | number>;
+    options: Record<string, any>;
+    url: string;
+    path: string;
+    params: Record<string, string | number | any>;
+    matches: string[];
+    pathPrefix: string;
+    private errorHandlers;
+    constructor(pathPrefix?: string);
+    add(...args: RouteParams[]): Router;
+    catch(...args: (number | string | Error | typeof Error | Middleware)[]): Router;
+    routes(): string[];
+    go(path: string, parentComponent?: Component | POJOComponent | VnodeComponentInterface): Promise<string | void>;
+    getOnClickHandler(url: string): (e: MouseEvent) => void;
+    private getAllRoutes;
+    private createRequest;
+    private getErrorConditionMiddlewares;
+    private handleError;
+    private searchComponent;
+}
+export declare function redirect(url: string, parentComponent?: Component | POJOComponent | VnodeComponentInterface, preventPushState?: boolean): Promise<string | void>;
+export declare function mountRouter(elementContainer: string | any, router: Router): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

dist/lib/signals/index.d.ts

@@ -0,0 +1,6 @@
+export type Signal<T> = [() => T, (newValue: T | ((current: T) => T)) => void, () => void];
+export declare function createSignal<T>(initialValue: T): Signal<T>;
+export declare function createEffect(effect: Function): void;
+export type SignalStore<T> = [() => T, (path: string, newValue: T | ((current: T) => T) | any) => void];
+export declare function createSignalStore<T>(initialState: T): SignalStore<T>;
+//# sourceMappingURL=index.d.ts.map

dist/lib/suspense/index.d.ts

@@ -0,0 +1,6 @@
+import { ValyrianComponent, Vnode, Children } from "valyrian.js";
+export declare function Suspense({ fallback, error }: {
+    fallback: any | Vnode | ValyrianComponent;
+    error?: (e: Error) => any | Vnode | ValyrianComponent;
+}, children: Children): Vnode;
+//# sourceMappingURL=index.d.ts.map

dist/lib/sw/index.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSw(file?: string, options?: RegistrationOptions): Promise<ServiceWorkerContainer | undefined>;
+//# sourceMappingURL=index.d.ts.map

dist/lib/translate/index.d.ts

@@ -0,0 +1,19 @@
+export declare function t(path: string, params?: Record<string, string>): string;
+export declare function setTranslations(defaultTranslation: Record<string, any>, newTranslations?: Record<string, Record<string, any>>): void;
+export declare function getTranslations(): Record<string, Record<string, any>>;
+export declare function setLang(newLang: string): void;
+export declare function getLang(): string;
+export declare class NumberFormatter {
+    #private;
+    get value(): number;
+    private constructor();
+    set(newValue: number | string, shiftDecimal?: boolean): this;
+    private clean;
+    format(digits?: number, options?: Intl.NumberFormatOptions, customLocale?: Intl.LocalesArgument): string;
+    fromDecimalPlaces(decimalPlaces: number): this;
+    toDecimalPlaces(decimalPlaces: number): this;
+    getDecimalPlaces(): number;
+    shiftDecimalPlaces(): this;
+    static create(value?: number | string, shiftDecimal?: boolean): NumberFormatter;
+}
+//# sourceMappingURL=index.d.ts.map

dist/lib/utils/deep-freeze.d.ts

@@ -0,0 +1,3 @@
+export declare function deepFreeze(obj: any): any;
+export declare function deepCloneUnfreeze<T>(obj: T): T;
+//# sourceMappingURL=deep-freeze.d.ts.map

dist/lib/utils/getter-setter.d.ts

@@ -0,0 +1,3 @@
+export declare function get(obj: unknown, path: string, defaultValue?: unknown): any;
+export declare function set(obj: any, path: string, value: any): void;
+//# sourceMappingURL=getter-setter.d.ts.map

dist/lib/utils/has-changed.d.ts

@@ -0,0 +1,2 @@
+export declare function hasChanged(prev: any, current: any): boolean;
+//# sourceMappingURL=has-changed.d.ts.map

dist/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./getter-setter";
+export * from "./has-changed";
+export * from "./deep-freeze";
+//# sourceMappingURL=index.d.ts.map

dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.7.2"}

package.json

@@ -193,7 +193,6 @@
     "hooks": {
       "before:init": [
         "bun run build",
-        "bun link",
         "bun run test"
       ],
       "after:bump": [
@@ -204,4 +203,4 @@
       ]
     }
   }
-}
+}

tsconfig.json

@@ -25,11 +25,11 @@
     "allowImportingTsExtensions": true,
     "resolveJsonModule": true,
 
-    "rootDir": "./lib",
+    "rootDir": "./",
     "paths": {
       "node_modules/*": ["./node_modules/*"]
     }
   },
-  "include": ["./lib", "./test", "./package.json"],
+  "include": ["./", "./lib"],
   "exclude": ["./lib/node/utils/node.sw.js"]
 }