eny-ai 1.0.0 → 2.0.0

package/dist/{chunk-E4KJZEXX.js → chunk-AJH2I5ZI.js}

@@ -1,4 +1,9 @@
+import {
+  init_esm_shims
+} from "./chunk-MXA7TAAG.js";
+
 // src/symbols.ts
+init_esm_shims();
 var TRUE = true;
 var FALSE = false;
 var VOID = null;

package/dist/chunk-LVJ3GJRQ.js

@@ -0,0 +1,360 @@
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-MXA7TAAG.js";
+
+// 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
+});
+var ENYRuntime, eny, state, substate, func, lambda, mapArray, filterArray, reduceArray;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    init_esm_shims();
+    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 = [];
+      }
+    };
+    eny = new ENYRuntime();
+    state = eny.\u03A3.bind(eny);
+    substate = eny.\u03C3.bind(eny);
+    func = eny.func.bind(eny);
+    lambda = eny.lambda.bind(eny);
+    mapArray = eny.map.bind(eny);
+    filterArray = eny.filter.bind(eny);
+    reduceArray = eny.reduce.bind(eny);
+  }
+});
+
+export {
+  ENYRuntime,
+  eny,
+  state,
+  substate,
+  func,
+  lambda,
+  mapArray,
+  filterArray,
+  reduceArray,
+  runtime_exports,
+  init_runtime
+};

package/dist/{chunk-PNKVD2UK.js → chunk-MXA7TAAG.js}

@@ -19,8 +19,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
 export {
   __esm,
   __export,
-  __toCommonJS
+  __toCommonJS,
+  init_esm_shims
 };

package/dist/cli.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import {
-  init_transpile,
   runENY,
   transpileToDTS,
   transpileToJS,
   transpileToWAT
-} from "./chunk-2WFUL4XJ.js";
-import "./chunk-PNKVD2UK.js";
+} from "./chunk-5PZUUNHS.js";
+import {
+  init_esm_shims
+} from "./chunk-MXA7TAAG.js";
 
 // src/cli.ts
+init_esm_shims();
 import fs from "fs";
 import path from "path";
-init_transpile();
 var argv = process.argv.slice(2);
 var code = "";
 var out;