eny-ai 1.0.0 → 2.0.0

package/dist/runtime.cjs

@@ -0,0 +1,366 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  ENYRuntime: () => ENYRuntime,
+  eny: () => eny,
+  filterArray: () => filterArray,
+  func: () => func,
+  lambda: () => lambda,
+  mapArray: () => mapArray,
+  reduceArray: () => reduceArray,
+  state: () => state,
+  substate: () => substate
+});
+module.exports = __toCommonJS(runtime_exports);
+var ENYRuntime = class {
+  constructor() {
+    this.context = {};
+    this.hooks = /* @__PURE__ */ new Map();
+    this.effects = [];
+    // ════════════════════════════════════════════════════════════════
+    // SÍMBOLOS HTTP/ASYNC
+    // ════════════════════════════════════════════════════════════════
+    /**
+     * http - HTTP methods
+     * http.GET(url), http.POST(url, data), etc
+     * Alias: ⇄
+     */
+    this.http = {
+      GET: async (url) => {
+        const res = await fetch(url);
+        return res.json();
+      },
+      POST: async (url, data) => {
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(data)
+        });
+        return res.json();
+      },
+      PUT: async (url, data) => {
+        const res = await fetch(url, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(data)
+        });
+        return res.json();
+      },
+      DELETE: async (url) => {
+        const res = await fetch(url, { method: "DELETE" });
+        return res.json();
+      }
+    };
+    // ════════════════════════════════════════════════════════════════
+    // SÍMBOLOS MEMÓRIA/STORAGE
+    // ════════════════════════════════════════════════════════════════
+    /**
+     * storage - Memory/Storage access
+     * storage.get(key), storage.set(key, value)
+     * Alias: 𝓜
+     */
+    this.storage = {
+      get: (key) => localStorage.getItem(key),
+      set: (key, value) => localStorage.setItem(key, JSON.stringify(value)),
+      remove: (key) => localStorage.removeItem(key),
+      clear: () => localStorage.clear(),
+      session: {
+        get: (key) => sessionStorage.getItem(key),
+        set: (key, value) => sessionStorage.setItem(key, JSON.stringify(value))
+      }
+    };
+    // ════════════════════════════════════════════════════════════════
+    // SÍMBOLOS SEGURANÇA
+    // ════════════════════════════════════════════════════════════════
+    /**
+     * validate - Validation helpers
+     * validate.email(str), validate.min(len)
+     * Alias: 🛡
+     */
+    this.validate = {
+      email: (str) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str),
+      min: (len) => (str) => str.length >= len,
+      max: (len) => (str) => str.length <= len,
+      regex: (pattern) => (str) => pattern.test(str),
+      required: (val) => val != null && val !== "",
+      equals: (expected) => (actual) => actual === expected
+    };
+    this.crypto = {
+      lock: (obj) => Object.freeze(obj),
+      unlock: (obj) => Object.assign({}, obj)
+    };
+    // ════════════════════════════════════════════════════════════════
+    // SÍMBOLOS NAVEGAÇÃO
+    // ════════════════════════════════════════════════════════════════
+    /**
+     * router - Router/Navigation
+     * router.navigate(path), router.back()
+     * Alias: 🧭
+     */
+    this.router = {
+      navigate: (path) => window.location.href = path,
+      back: () => window.history.back(),
+      forward: () => window.history.forward(),
+      reload: () => window.location.reload(),
+      params: () => new URLSearchParams(window.location.search)
+    };
+    // ════════════════════════════════════════════════════════════════
+    // SISTEMA DE LOGS
+    // ════════════════════════════════════════════════════════════════
+    /**
+     * logger - Logging system
+     * logger.info(msg), logger.error(msg), logger.warn(msg)
+     * Alias: 📜
+     */
+    this.logger = {
+      info: (msg, data) => console.log(`\u2139\uFE0F ${msg}`, data),
+      error: (msg, data) => console.error(`\u274C ${msg}`, data),
+      warn: (msg, data) => console.warn(`\u26A0\uFE0F ${msg}`, data),
+      log: (msg, data) => console.log(`\u{1F4DC} ${msg}`, data)
+    };
+  }
+  // ════════════════════════════════════════════════════════════════
+  // SÍMBOLOS BÁSICOS - ESTADO
+  // ════════════════════════════════════════════════════════════════
+  /**
+   * Σ - Cria estado global
+   * Σ('user', { name: 'João' })
+   */
+  \u03A3(key, initialValue) {
+    if (!this.context[key]) {
+      this.context[key] = initialValue;
+    }
+    return {
+      get: () => this.context[key],
+      set: (value) => {
+        this.context[key] = value;
+        this.notify();
+      },
+      value: this.context[key]
+    };
+  }
+  /**
+   * σ - Sub-estado (local)
+   * σ(parent, 'field')
+   */
+  \u03C3(parent, field) {
+    return {
+      get: () => parent[field],
+      set: (value) => {
+        parent[field] = value;
+      },
+      value: parent[field]
+    };
+  }
+  /**
+   * ⊤ e ⊥ - Booleanos
+   */
+  get TRUE() {
+    return true;
+  }
+  get FALSE() {
+    return false;
+  }
+  // Aliases simbólicos para compatibilidade
+  get trueValue() {
+    return true;
+  }
+  get falseValue() {
+    return false;
+  }
+  /**
+   * Ø - Nulo/Vazio
+   */
+  get \u00D8() {
+    return null;
+  }
+  // ════════════════════════════════════════════════════════════════
+  // SÍMBOLOS FUNCIONAIS - FUNÇÕES
+  // ════════════════════════════════════════════════════════════════
+  /**
+   * func - Define função normal
+   * func('myFunc', (a, b) => a + b)
+   */
+  func(name, fn) {
+    const wrapped = fn;
+    this.context[name] = wrapped;
+    return wrapped;
+  }
+  // Alias: ƒ
+  get \u0192() {
+    return this.func.bind(this);
+  }
+  /**
+   * lambda - Arrow function/Lambda
+   * lambda(fn) - wraps e memoiza
+   */
+  lambda(fn) {
+    return fn;
+  }
+  // Alias: λ
+  get \u03BB() {
+    return this.lambda.bind(this);
+  }
+  // ════════════════════════════════════════════════════════════════
+  // SÍMBOLOS DE ARRAY - ITERAÇÃO
+  // ════════════════════════════════════════════════════════════════
+  /**
+   * map - Map operator
+   * arr.map((item) => item * 2)
+   * Alias: ↦
+   */
+  map(arr, fn) {
+    return arr.map((item) => fn(item));
+  }
+  /**
+   * filter - Filter operator
+   * arr.filter((item) => item > 5)
+   * Alias: ⊳
+   */
+  filter(arr, predicate) {
+    return arr.filter((item) => predicate(item));
+  }
+  /**
+   * reduce - Reduce operator
+   * arr.reduce((acc, item) => acc + item, 0)
+   * Alias: ⊲
+   */
+  reduce(arr, reducer, initial = 0) {
+    return arr.reduce((acc, item) => reducer(acc, item), initial);
+  }
+  /**
+   * find - Find operator
+   * arr.find((item) => item.id === 5)
+   * Alias: ⊙
+   */
+  find(arr, predicate) {
+    return arr.find((item) => predicate(item));
+  }
+  /**
+   * every - Every operator
+   * arr.every((item) => item > 0)
+   * Alias: ∀
+   */
+  every(arr, predicate) {
+    return arr.every((item) => predicate(item));
+  }
+  /**
+   * some - Some operator
+   * arr.some((item) => item > 0)
+   * Alias: ∃
+   */
+  some(arr, predicate) {
+    return arr.some((item) => predicate(item));
+  }
+  // ════════════════════════════════════════════════════════════════
+  // SÍMBOLOS OPERADORES
+  // ════════════════════════════════════════════════════════════════
+  /**
+   * assign - Assignment operator
+   * Alias: ←
+   */
+  assign(target, value) {
+    return value;
+  }
+  /**
+   * and - AND operator
+   * Alias: ∧
+   */
+  and(a, b) {
+    return a && b;
+  }
+  /**
+   * or - OR operator
+   * Alias: ∨
+   */
+  or(a, b) {
+    return a || b;
+  }
+  /**
+   * not - NOT operator
+   * Alias: ¬
+   */
+  not(a) {
+    return !a;
+  }
+  /**
+   * merge - Merge/Spread operator
+   * Alias: ⊕
+   */
+  merge(...objs) {
+    return Object.assign({}, ...objs);
+  }
+  /**
+   * encode - Basic encoding/decoding
+   * Alias: 🔑 🔒 🔓
+   */
+  encode(data) {
+    return btoa(data);
+  }
+  // ════════════════════════════════════════════════════════════════
+  // INTERNALS
+  // ════════════════════════════════════════════════════════════════
+  notify() {
+    this.effects.forEach((effect) => effect());
+  }
+  /**
+   * effect - Register effect function
+   * Alias: ⚡
+   */
+  effect(fn, deps = []) {
+    this.effects.push(() => fn());
+  }
+  /**
+   * Obter todo contexto
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Limpar runtime
+   */
+  clear() {
+    this.context = {};
+    this.hooks.clear();
+    this.effects = [];
+  }
+};
+var eny = new ENYRuntime();
+var state = eny.\u03A3.bind(eny);
+var substate = eny.\u03C3.bind(eny);
+var func = eny.func.bind(eny);
+var lambda = eny.lambda.bind(eny);
+var mapArray = eny.map.bind(eny);
+var filterArray = eny.filter.bind(eny);
+var reduceArray = eny.reduce.bind(eny);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENYRuntime,
+  eny,
+  filterArray,
+  func,
+  lambda,
+  mapArray,
+  reduceArray,
+  state,
+  substate
+});

package/dist/runtime.d.cts

@@ -0,0 +1,229 @@
+/**
+ * 🧠 ENY-AI RUNTIME v2.0
+ * Interprete simbólico universal
+ * Executa 90% código simbólico SEM build
+ */
+interface SymbolContext {
+    [key: string]: any;
+}
+declare class ENYRuntime {
+    private context;
+    private hooks;
+    private effects;
+    /**
+     * Σ - Cria estado global
+     * Σ('user', { name: 'João' })
+     */
+    Σ(key: string, initialValue: any): {
+        get: () => any;
+        set: (value: any) => void;
+        value: any;
+    };
+    /**
+     * σ - Sub-estado (local)
+     * σ(parent, 'field')
+     */
+    σ(parent: any, field: string): {
+        get: () => any;
+        set: (value: any) => void;
+        value: any;
+    };
+    /**
+     * ⊤ e ⊥ - Booleanos
+     */
+    get TRUE(): boolean;
+    get FALSE(): boolean;
+    get trueValue(): boolean;
+    get falseValue(): boolean;
+    /**
+     * Ø - Nulo/Vazio
+     */
+    get Ø(): null;
+    /**
+     * func - Define função normal
+     * func('myFunc', (a, b) => a + b)
+     */
+    func(name: string, fn: Function): Function;
+    get ƒ(): (name: string, fn: Function) => Function;
+    /**
+     * lambda - Arrow function/Lambda
+     * lambda(fn) - wraps e memoiza
+     */
+    lambda(fn: Function): Function;
+    get λ(): (fn: Function) => Function;
+    /**
+     * map - Map operator
+     * arr.map((item) => item * 2)
+     * Alias: ↦
+     */
+    map(arr: any[], fn: Function): any[];
+    /**
+     * filter - Filter operator
+     * arr.filter((item) => item > 5)
+     * Alias: ⊳
+     */
+    filter(arr: any[], predicate: Function): any[];
+    /**
+     * reduce - Reduce operator
+     * arr.reduce((acc, item) => acc + item, 0)
+     * Alias: ⊲
+     */
+    reduce(arr: any[], reducer: Function, initial?: any): any;
+    /**
+     * find - Find operator
+     * arr.find((item) => item.id === 5)
+     * Alias: ⊙
+     */
+    find(arr: any[], predicate: Function): any;
+    /**
+     * every - Every operator
+     * arr.every((item) => item > 0)
+     * Alias: ∀
+     */
+    every(arr: any[], predicate: Function): boolean;
+    /**
+     * some - Some operator
+     * arr.some((item) => item > 0)
+     * Alias: ∃
+     */
+    some(arr: any[], predicate: Function): boolean;
+    /**
+     * assign - Assignment operator
+     * Alias: ←
+     */
+    assign(target: any, value: any): any;
+    /**
+     * and - AND operator
+     * Alias: ∧
+     */
+    and(a: any, b: any): any;
+    /**
+     * or - OR operator
+     * Alias: ∨
+     */
+    or(a: any, b: any): any;
+    /**
+     * not - NOT operator
+     * Alias: ¬
+     */
+    not(a: any): boolean;
+    /**
+     * merge - Merge/Spread operator
+     * Alias: ⊕
+     */
+    merge(...objs: any[]): any;
+    /**
+     * http - HTTP methods
+     * http.GET(url), http.POST(url, data), etc
+     * Alias: ⇄
+     */
+    http: {
+        GET: (url: string) => Promise<any>;
+        POST: (url: string, data: any) => Promise<any>;
+        PUT: (url: string, data: any) => Promise<any>;
+        DELETE: (url: string) => Promise<any>;
+    };
+    /**
+     * storage - Memory/Storage access
+     * storage.get(key), storage.set(key, value)
+     * Alias: 𝓜
+     */
+    storage: {
+        get: (key: string) => string | null;
+        set: (key: string, value: any) => void;
+        remove: (key: string) => void;
+        clear: () => void;
+        session: {
+            get: (key: string) => string | null;
+            set: (key: string, value: any) => void;
+        };
+    };
+    /**
+     * validate - Validation helpers
+     * validate.email(str), validate.min(len)
+     * Alias: 🛡
+     */
+    validate: {
+        email: (str: string) => boolean;
+        min: (len: number) => (str: string) => boolean;
+        max: (len: number) => (str: string) => boolean;
+        regex: (pattern: RegExp) => (str: string) => boolean;
+        required: (val: any) => boolean;
+        equals: (expected: any) => (actual: any) => boolean;
+    };
+    /**
+     * encode - Basic encoding/decoding
+     * Alias: 🔑 🔒 🔓
+     */
+    encode(data: string): string;
+    crypto: {
+        lock: (obj: any) => any;
+        unlock: (obj: any) => any;
+    };
+    /**
+     * router - Router/Navigation
+     * router.navigate(path), router.back()
+     * Alias: 🧭
+     */
+    router: {
+        navigate: (path: string) => string;
+        back: () => void;
+        forward: () => void;
+        reload: () => void;
+        params: () => URLSearchParams;
+    };
+    /**
+     * logger - Logging system
+     * logger.info(msg), logger.error(msg), logger.warn(msg)
+     * Alias: 📜
+     */
+    logger: {
+        info: (msg: string, data?: any) => void;
+        error: (msg: string, data?: any) => void;
+        warn: (msg: string, data?: any) => void;
+        log: (msg: string, data?: any) => void;
+    };
+    private notify;
+    /**
+     * effect - Register effect function
+     * Alias: ⚡
+     */
+    effect(fn: Function, deps?: any[]): void;
+    /**
+     * Obter todo contexto
+     */
+    getContext(): {
+        [key: string]: any;
+    };
+    /**
+     * Limpar runtime
+     */
+    clear(): void;
+}
+declare const eny: ENYRuntime;
+/**
+ * Aliases para uso direto com nomes válidos ASCII
+ * Para símbolos emoji, use: eny.method() ou destructure
+ *
+ * Exemplos:
+ * const sum = eny.Σ.bind(eny)  // State creation
+ * const mapFn = eny.map.bind(eny)  // Array mapping (alias: ↦)
+ * const filterFn = eny.filter.bind(eny)  // Array filtering (alias: ⊳)
+ */
+declare const state: (key: string, initialValue: any) => {
+    get: () => any;
+    set: (value: any) => void;
+    value: any;
+};
+declare const substate: (parent: any, field: string) => {
+    get: () => any;
+    set: (value: any) => void;
+    value: any;
+};
+declare const func: (name: string, fn: Function) => Function;
+declare const lambda: (fn: Function) => Function;
+declare const mapArray: (arr: any[], fn: Function) => any[];
+declare const filterArray: (arr: any[], predicate: Function) => any[];
+declare const reduceArray: (arr: any[], reducer: Function, initial?: any) => any;
+
+export { ENYRuntime, type SymbolContext, eny, filterArray, func, lambda, mapArray, reduceArray, state, substate };