@mulanjs/mulanjs 1.0.1-dev.20260212143840

package/dist/security/sanitizer.js

@@ -0,0 +1,47 @@
+export class Security {
+    static sanitize(input) {
+        // 1. Basic entity encoding
+        let secure = input
+            .replace(/&/g, "&")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+        // 2. Remove dangerous events (extra layer if encoding fails)
+        const dangerousEvents = ['onload', 'onclick', 'onerror', 'onmouseover', 'onfocus'];
+        dangerousEvents.forEach(event => {
+            const regex = new RegExp(event, 'gi');
+            secure = secure.replace(regex, 'data-blocked-' + event);
+        });
+        return secure;
+    }
+    /**
+     * Generates a strict Content Security Policy header value.
+     * @param options Configuration for allowed sources
+     */
+    static generateCSP(options = {}) {
+        const scriptSrc = ["'self'", ...(options.scriptSrc || [])].join(" ");
+        const styleSrc = ["'self'", "'unsafe-inline'", ...(options.styleSrc || [])].join(" ");
+        return `default-src 'self'; script-src ${scriptSrc}; style-src ${styleSrc}; object-src 'none'; base-uri 'self';`;
+    }
+    static validateUrl(url) {
+        // Basic URL validation
+        const pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+            '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+        return !!pattern.test(url);
+    }
+    /**
+     * Prevents XSS by sanitizing common input fields on blur.
+     * Can be used as a utility in forms.
+     */
+    static preventXSS(inputElement) {
+        inputElement.addEventListener('blur', (e) => {
+            const target = e.target;
+            target.value = Security.sanitize(target.value);
+        });
+    }
+}

package/dist/store/index.js

@@ -0,0 +1,42 @@
+import { reactive, effect } from '../core/reactive';
+export class MuStore {
+    constructor(initialState, options) {
+        this.subscribers = [];
+        // Load from local storage if persist is true
+        let loadedState = initialState;
+        if (options === null || options === void 0 ? void 0 : options.persist) {
+            const key = options.key || 'mulan-store';
+            try {
+                const stored = localStorage.getItem(key);
+                if (stored) {
+                    loadedState = Object.assign(Object.assign({}, initialState), JSON.parse(stored));
+                }
+            }
+            catch (e) {
+                console.error("Failed to load state", e);
+            }
+            // Auto-save effect
+            effect(() => {
+                localStorage.setItem(key, JSON.stringify(this.state));
+            });
+        }
+        this.state = reactive(loadedState);
+    }
+    // Subscribe to changes
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        effect(() => {
+            fn(this.state);
+        });
+    }
+    // Action dispatcher pattern
+    dispatch(action) {
+        const result = action(this.state);
+        if (result instanceof Promise) {
+            result.then(() => {
+                // Optional: Notify subscribers of async completion if needed manually?
+                // But reactive() handles updates automatically.
+            });
+        }
+    }
+}

package/dist/types/compiler/compiler.d.ts

@@ -0,0 +1,7 @@
+export interface CompileResult {
+    code: string;
+    css: string;
+    errors: string[];
+    map?: string;
+}
+export declare function compileSFC(source: string, filename: string): CompileResult;

package/dist/types/compiler/script-compiler.d.ts

@@ -0,0 +1,8 @@
+import { SFCDescriptor } from './sfc-parser';
+export interface ScriptCompileResult {
+    code: string;
+    bindings?: string[];
+    errors: string[];
+    map?: string;
+}
+export declare function compileScript(descriptor: SFCDescriptor): ScriptCompileResult;

package/dist/types/compiler/sfc-parser.d.ts

@@ -0,0 +1,21 @@
+export interface SFCBlock {
+    type: 'script' | 'template' | 'style';
+    content: string;
+    attrs: Record<string, string>;
+    start: number;
+    end: number;
+}
+export interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCBlock | null;
+    script: SFCBlock | null;
+    scripts: SFCBlock[];
+    styles: SFCBlock[];
+    customBlocks: SFCBlock[];
+}
+/**
+ * Standardized State-Machine Parser for MulanJS
+ * Parses .mujs files safely, handling attributes, quotes, and nested content.
+ */
+export declare function parseMUJS(source: string, filename: string): SFCDescriptor;

package/dist/types/compiler/style-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+export interface StyleCompileResult {
+    css: string;
+    scopedId?: string;
+    errors: string[];
+}
+export declare function compileStyle(descriptor: SFCDescriptor, filename: string): StyleCompileResult;

package/dist/types/compiler/template-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+import { ScriptCompileResult } from './script-compiler';
+export interface TemplateCompileResult {
+    code: string;
+    errors: string[];
+}
+export declare function compileTemplate(descriptor: SFCDescriptor, scriptResult: ScriptCompileResult, scopedId?: string): TemplateCompileResult;

package/dist/types/compiler.d.ts

@@ -0,0 +1,7 @@
+export interface CompileResult {
+    code: string;
+    css: string;
+    errors: string[];
+    map?: string;
+}
+export declare function compileSFC(source: string, filename: string): CompileResult;

package/dist/types/components/bloch-sphere.d.ts

@@ -0,0 +1,16 @@
+export declare class MuBlochSphereElement extends HTMLElement {
+    private _qubit;
+    private _arrow;
+    private _container;
+    private _disposeEffect;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    set qubit(val: any);
+    get qubit(): any;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    initReactivity(): void;
+    updateArrow(theta: number, phi: number): void;
+    render(): void;
+}

package/dist/types/core/component.d.ts

@@ -0,0 +1,54 @@
+export type FunctionalSetup = () => (() => string);
+export declare abstract class MuComponent {
+    state: any;
+    container: HTMLElement;
+    $uid: string;
+    _hooks: {
+        onMuInit?: Array<() => void>;
+        onMuMount?: Array<() => void>;
+        onMuDestroy?: Array<() => void>;
+    };
+    _effects: Array<() => void>;
+    _isDestroyed: boolean;
+    constructor(container: HTMLElement);
+    setup(): void;
+    abstract template(): string;
+    onMount(): void;
+    onUpdate(): void;
+    onDestroy(): void;
+    _propsQueue: Array<[string, string, any]>;
+    _eventQueue: Array<[string, string, Function]>;
+    _b(id: string, prop: string, value: any): string;
+    _e(id: string, type: string, handler: Function): string;
+    mount(): void;
+    update(): void;
+    flushProps(): void;
+    flushEvents(): void;
+}
+export declare function defineComponent(optionsOrSetup: any): {
+    new (container: HTMLElement): {
+        setup(): void;
+        template(): string;
+        state: any;
+        container: HTMLElement;
+        $uid: string;
+        _hooks: {
+            onMuInit?: Array<() => void>;
+            onMuMount?: Array<() => void>;
+            onMuDestroy?: Array<() => void>;
+        };
+        _effects: Array<() => void>;
+        _isDestroyed: boolean;
+        onMount(): void;
+        onUpdate(): void;
+        onDestroy(): void;
+        _propsQueue: Array<[string, string, any]>;
+        _eventQueue: Array<[string, string, Function]>;
+        _b(id: string, prop: string, value: any): string;
+        _e(id: string, type: string, handler: Function): string;
+        mount(): void;
+        update(): void;
+        flushProps(): void;
+        flushEvents(): void;
+    };
+};

package/dist/types/core/hooks.d.ts

@@ -0,0 +1,49 @@
+export declare function setCurrentInstance(instance: any): void;
+export declare function getCurrentInstance(): any;
+export declare function muState<T>(initialValue: T): any;
+export declare function muMemo<T>(computeFn: () => T): {
+    value: T;
+};
+export declare function muEffect(fn: () => void): void;
+export declare function onMuInit(fn: () => void): void;
+export declare function onMuMount(fn: () => void): void;
+export declare function onMuDestroy(fn: () => void): void;
+/**
+ * onMuIdle - The "Environment Life" Hook.
+ * Executes heavy logic ONLY when the browser is taking a nap (idle).
+ */
+export declare function onMuIdle(fn: () => void): void;
+/**
+ * onMuResume - The "Tab Life" Hook.
+ * Executes when the user switches BACK to this tab.
+ * Perfect for refreshing data or resuming animations to save battery.
+ */
+export declare function onMuResume(fn: () => void): void;
+/**
+ * onMuShake - The "Physical Life" Hook.
+ * Executes when the device is shaken.
+ * Usage: Undo, Refresh, or "Rage Quit" easter eggs.
+ */
+export declare function onMuShake(fn: () => void): void;
+/**
+ * onMuVoice - The "Sound Life" Hook.
+ * Executes when a specific word is spoken.
+ * @param command The word to listen for (e.g., "save", "next")
+ * @param fn The action to take
+ */
+export declare function onMuVoice(command: string, fn: () => void): void;
+/**
+ * muGeom - Tracks window or element dimensions reactively.
+ */
+export declare function muGeom(): any;
+/**
+ * muPulse - Reactive network status.
+ */
+export declare function muPulse(): any;
+/**
+ * muVault - Secure reactive LocalStorage wrapper.
+ * Powered by the Iron Fortress persistent primitive.
+ */
+export declare function muVault<T>(key: string, initial: T, options?: {
+    encrypt?: boolean;
+}): any;

package/dist/types/core/quantum.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Mulan Quantum (ASTR-Q+) Core
+ * Advanced Simulation Engine for multi-qubit registers and entanglement.
+ */
+export interface Amplitude {
+    re: number;
+    im: number;
+}
+export interface QuantumState {
+    size: number;
+    amplitudes: Amplitude[];
+    alpha?: Amplitude;
+    beta?: Amplitude;
+}
+/**
+ * Creates a quantum register of size n.
+ * State vector will have 2^n amplitudes.
+ */
+export declare function muRegister(n: number): any;
+/**
+ * Backward compatible muQubit (Single Qubit Register)
+ */
+export declare function muQubit(initial?: 0 | 1): any;
+export type GateType = 'H' | 'X' | 'Z' | 'Y' | 'CNOT' | 'CZ' | 'SWAP';
+export declare function muGate(reg: any, type: GateType, target?: number, control?: number | number[]): void;
+/**
+ * Mulan Search Logic (Grover's Operator)
+ * Automatically constructs a multi-controlled Phase Flip (Z) for a specific target state.
+ * This is the core of the "Quantum Switch" or "Quantum Search" capability.
+ * @param reg Quantum Register
+ * @param targetState The integer state to "search" and mark (e.g. 2 for |10>)
+ */
+export declare function muSearch(reg: any, targetState: number): void;
+export declare function muEntangle(reg: any, i: number, j: number): void;
+/**
+ * Quantum Teleportation Protocol
+ * Transfers the state of `msgIdx` to `targetIdx` using `ancillaIdx` as a resource.
+ * @param reg Register
+ * @param msgIdx The qubit containing the state to teleport (Alice)
+ * @param ancillaIdx The helper qubit (Alice's half of entanglement)
+ * @param targetIdx The destination qubit (Bob)
+ */
+export declare function muTeleport(reg: any, msgIdx: number, ancillaIdx: number, targetIdx: number): void;
+/**
+ * Measures a specific qubit in the register, collapsing the superposition.
+ * @param reg Quantum Register
+ * @param target Index of qubit to measure
+ * @returns 0 or 1
+ */
+export declare function muMeasure(reg: any, target?: number): number;

package/dist/types/core/query.d.ts

@@ -0,0 +1,14 @@
+export declare function useQuery<T>(queryFn: () => Promise<T>, options?: {
+    enabled?: boolean;
+}): {
+    refetch: () => Promise<void>;
+    data: T | null;
+    isLoading: boolean;
+    error: any;
+};
+export declare function useMutation<T, A = void>(mutationFn: (args: A) => Promise<T>): {
+    mutate: (args: A) => Promise<T>;
+    data: T | null;
+    isLoading: boolean;
+    error: any;
+};

package/dist/types/core/reactive.d.ts

@@ -0,0 +1,21 @@
+type Effect = () => void;
+export declare class Signal<T> {
+    private _value;
+    private _subscribers;
+    constructor(initialValue: T);
+    get value(): T;
+    set value(newValue: T);
+    notify(): void;
+}
+export declare function effect(fn: Effect): () => void;
+/**
+ * Creates a reactive proxy object (Vue-compatible).
+ * Now optimized to respect Mulan Cycle.
+ */
+export declare function reactive<T extends object>(target: T): T;
+/**
+ * Creates a standalone reactive reference.
+ * Backed by the Mulan Signal Engine.
+ */
+export declare function ref<T>(value: T): Signal<T>;
+export {};

package/dist/types/core/renderer.d.ts

@@ -0,0 +1,4 @@
+export declare function render(template: string, container: HTMLElement): void;
+export declare function hydrate(template: string, container: HTMLElement): void;
+export declare function renderToString(template: string): string;
+export declare function sanitize(str: string): string;

package/dist/types/core/vault.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Options for Mulan Vault
+ */
+export interface VaultOptions {
+    encrypt?: boolean;
+    storage?: Storage;
+}
+/**
+ * Mulan Vault: The World's First Native Persistent State Primitive.
+ * Now fortified with Iron Fortress Obfuscation.
+ */
+export declare function persistent<T>(key: string, initialValue: T, options?: VaultOptions): any;

package/dist/types/index.d.ts

@@ -0,0 +1,70 @@
+export * from './core/reactive';
+export { MuComponent, MuComponent as Component, defineComponent } from './core/component';
+export * from './core/renderer';
+export { MuRouter, MuRouter as Router, Route } from './router/index';
+export { MuStore } from './store/index';
+export * from './security/sanitizer';
+export * from './core/hooks';
+export * from './core/query';
+export * from './core/vault';
+export * from './core/quantum';
+export * from './components/bloch-sphere';
+import { reactive, effect } from './core/reactive';
+import { MuComponent, defineComponent } from './core/component';
+import { MuRouter } from './router/index';
+import { MuStore } from './store/index';
+import { Security } from './security/sanitizer';
+import * as Quantum from './core/quantum';
+declare const Mulan: {
+    log: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+    muRegister(n: number): any;
+    muQubit(initial?: 0 | 1): any;
+    muGate(reg: any, type: Quantum.GateType, target?: number, control?: number | number[]): void;
+    muSearch(reg: any, targetState: number): void;
+    muEntangle(reg: any, i: number, j: number): void;
+    muTeleport(reg: any, msgIdx: number, ancillaIdx: number, targetIdx: number): void;
+    muMeasure(reg: any, target?: number): number;
+    useQuery<T>(queryFn: () => Promise<T>, options?: {
+        enabled?: boolean;
+    }): {
+        refetch: () => Promise<void>;
+        data: T | null;
+        isLoading: boolean;
+        error: any;
+    };
+    useMutation<T, A = void>(mutationFn: (args: A) => Promise<T>): {
+        mutate: (args: A) => Promise<T>;
+        data: T | null;
+        isLoading: boolean;
+        error: any;
+    };
+    setCurrentInstance(instance: any): void;
+    getCurrentInstance(): any;
+    muState<T>(initialValue: T): any;
+    muMemo<T>(computeFn: () => T): {
+        value: T;
+    };
+    muEffect(fn: () => void): void;
+    onMuInit(fn: () => void): void;
+    onMuMount(fn: () => void): void;
+    onMuDestroy(fn: () => void): void;
+    onMuIdle(fn: () => void): void;
+    onMuResume(fn: () => void): void;
+    onMuShake(fn: () => void): void;
+    onMuVoice(command: string, fn: () => void): void;
+    muGeom(): any;
+    muPulse(): any;
+    muVault<T>(key: string, initial: T, options?: {
+        encrypt?: boolean;
+    }): any;
+    reactive: typeof reactive;
+    effect: typeof effect;
+    Component: typeof MuComponent;
+    defineComponent: typeof defineComponent;
+    Router: typeof MuRouter;
+    Store: typeof MuStore;
+    Security: typeof Security;
+};
+export default Mulan;

package/dist/types/router/index.d.ts

@@ -0,0 +1,24 @@
+export interface Route {
+    path: string;
+    component: any | (() => Promise<any>);
+    beforeEnter?: (to: string, from: string, next: (allow: boolean) => void) => void;
+    meta?: Record<string, any>;
+    title?: string;
+}
+export declare class MuRouter {
+    routes: Route[];
+    rootContainer: HTMLElement | null;
+    currentPath: string;
+    currentComponent: any;
+    isServer: boolean;
+    private lastRouteId;
+    constructor(routes: Route[], rootContainer?: HTMLElement | null);
+    serverLookup(path: string): Promise<string>;
+    private matchRoute;
+    handleRoute(): Promise<void>;
+    navigate(path: string): void;
+}
+export declare const createRouter: (options: {
+    routes: Route[];
+    rootContainer?: HTMLElement | null;
+}) => MuRouter;

package/dist/types/script-compiler.d.ts

@@ -0,0 +1,8 @@
+import { SFCDescriptor } from './sfc-parser';
+export interface ScriptCompileResult {
+    code: string;
+    bindings?: string[];
+    errors: string[];
+    map?: string;
+}
+export declare function compileScript(descriptor: SFCDescriptor): ScriptCompileResult;

package/dist/types/security/sanitizer.d.ts

@@ -0,0 +1,17 @@
+export declare class Security {
+    static sanitize(input: string): string;
+    /**
+     * Generates a strict Content Security Policy header value.
+     * @param options Configuration for allowed sources
+     */
+    static generateCSP(options?: {
+        scriptSrc?: string[];
+        styleSrc?: string[];
+    }): string;
+    static validateUrl(url: string): boolean;
+    /**
+     * Prevents XSS by sanitizing common input fields on blur.
+     * Can be used as a utility in forms.
+     */
+    static preventXSS(inputElement: HTMLInputElement | HTMLTextAreaElement): void;
+}

package/dist/types/sfc-parser.d.ts

@@ -0,0 +1,21 @@
+export interface SFCBlock {
+    type: 'script' | 'template' | 'style';
+    content: string;
+    attrs: Record<string, string>;
+    start: number;
+    end: number;
+}
+export interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCBlock | null;
+    script: SFCBlock | null;
+    scripts: SFCBlock[];
+    styles: SFCBlock[];
+    customBlocks: SFCBlock[];
+}
+/**
+ * Standardized State-Machine Parser for MulanJS
+ * Parses .mujs files safely, handling attributes, quotes, and nested content.
+ */
+export declare function parseMUJS(source: string, filename: string): SFCDescriptor;

package/dist/types/store/index.d.ts

@@ -0,0 +1,10 @@
+export declare class MuStore<T extends object> {
+    state: T;
+    private subscribers;
+    constructor(initialState: T, options?: {
+        persist?: boolean;
+        key?: string;
+    });
+    subscribe(fn: (state: T) => void): void;
+    dispatch(action: (state: T) => void | Promise<void>): void;
+}

package/dist/types/style-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+export interface StyleCompileResult {
+    css: string;
+    scopedId?: string;
+    errors: string[];
+}
+export declare function compileStyle(descriptor: SFCDescriptor, filename: string): StyleCompileResult;

package/dist/types/template-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+import { ScriptCompileResult } from './script-compiler';
+export interface TemplateCompileResult {
+    code: string;
+    errors: string[];
+}
+export declare function compileTemplate(descriptor: SFCDescriptor, scriptResult: ScriptCompileResult, scopedId?: string): TemplateCompileResult;

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@mulanjs/mulanjs",
+    "version": "1.0.1-dev.20260212143840",
+    "description": "A powerful, secure, and enterprise-grade JavaScript framework.",
+    "main": "dist/mulan.js",
+    "module": "dist/mulan.esm.js",
+    "browser": "dist/mulan.js",
+    "bin": {
+        "mulan": "./src/cli/index.js"
+    },
+    "types": "dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/mulan.esm.js",
+            "require": "./dist/mulan.js"
+        },
+        "./loader": "./src/loader/index.js"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "src/cli",
+        "src/compiler",
+        "src/loader"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc && tsc -p src/compiler/tsconfig.json && npm run bundle",
+        "bundle": "webpack",
+        "test": "jest",
+        "prepublishOnly": "npm run build && npm run bundle && npm test",
+        "publish:dev": "node scripts/publish-dev.js"
+    },
+    "keywords": [
+        "framework",
+        "mulanjs",
+        "component",
+        "router",
+        "store",
+        "security"
+    ],
+    "author": "MulanJS Team",
+    "license": "MIT",
+    "dependencies": {
+        "commander": "^14.0.3",
+        "fs-extra": "^11.3.3",
+        "webpack": "^5.104.1",
+        "webpack-cli": "^6.0.1",
+        "webpack-dev-server": "^5.2.0",
+        "ts-loader": "^9.5.4",
+        "typescript": "^5.0.0"
+    },
+    "devDependencies": {
+        "@types/fs-extra": "^11.0.4",
+        "@types/jest": "^30.0.0",
+        "jest": "^30.2.0",
+        "jest-environment-jsdom": "^30.2.0",
+        "ts-jest": "^29.4.6"
+    }
+}