eny-ai 1.0.0

package/dist/react/index.js

@@ -0,0 +1,284 @@
+import "../chunk-PNKVD2UK.js";
+
+// src/react/index.ts
+import { useState, useEffect, useReducer, useCallback, useRef, createElement } from "react";
+function useStateSymbol(initial) {
+  return useState(initial);
+}
+function usePersistentState(key, initial) {
+  const [state, setState] = useState(() => {
+    if (typeof window === "undefined") return initial;
+    const stored = localStorage.getItem(key);
+    return stored ? JSON.parse(stored) : initial;
+  });
+  useEffect(() => {
+    localStorage.setItem(key, JSON.stringify(state));
+  }, [key, state]);
+  return [state, setState];
+}
+function useReducerSymbol(reducer, initial) {
+  return useReducer(reducer, initial);
+}
+function useEffectSymbol(effectFn, deps) {
+  useEffect(effectFn, deps);
+}
+function useDebounce(value, delay) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debounced;
+}
+function useInterval(callback, delay) {
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (delay === null) return;
+    const id = setInterval(() => savedCallback.current(), delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+function useFetch(url, options) {
+  const [state, setState] = useState({
+    data: null,
+    loading: true,
+    error: null
+  });
+  useEffect(() => {
+    let cancelled = false;
+    fetch(url, options).then((res) => res.json()).then((data) => {
+      if (!cancelled) setState({ data, loading: false, error: null });
+    }).catch((error) => {
+      if (!cancelled) setState({ data: null, loading: false, error });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [url]);
+  return state;
+}
+function useGet(url) {
+  return useFetch(url);
+}
+function usePost(url) {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const post = useCallback(async (body) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      const data = await res.json();
+      setLoading(false);
+      return data;
+    } catch (e) {
+      setError(e);
+      setLoading(false);
+      throw e;
+    }
+  }, [url]);
+  return { post, loading, error };
+}
+var storage = {
+  get: function getStorage(key) {
+    if (typeof window === "undefined") return null;
+    const item = localStorage.getItem(key);
+    return item ? JSON.parse(item) : null;
+  },
+  set: function setStorage(key, value) {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(key, JSON.stringify(value));
+  },
+  remove: function removeStorage(key) {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(key);
+  },
+  clear: function clearStorage() {
+    if (typeof window === "undefined") return;
+    localStorage.clear();
+  }
+};
+var sessionStore = {
+  get: function getSession(key) {
+    if (typeof window === "undefined") return null;
+    const item = sessionStorage.getItem(key);
+    return item ? JSON.parse(item) : null;
+  },
+  set: function setSession(key, value) {
+    if (typeof window === "undefined") return;
+    sessionStorage.setItem(key, JSON.stringify(value));
+  },
+  remove: function removeSession(key) {
+    if (typeof window === "undefined") return;
+    sessionStorage.removeItem(key);
+  }
+};
+var nav = {
+  to: (path) => {
+    if (typeof window !== "undefined") {
+      window.location.href = path;
+    }
+  },
+  back: () => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  },
+  reload: () => {
+    if (typeof window !== "undefined") {
+      window.location.reload();
+    }
+  },
+  params: () => {
+    if (typeof window === "undefined") return new URLSearchParams();
+    return new URLSearchParams(window.location.search);
+  },
+  hash: () => {
+    if (typeof window === "undefined") return "";
+    return window.location.hash;
+  }
+};
+function mapArr(arr, fn) {
+  return arr.map(fn);
+}
+function filterArr(arr, fn) {
+  return arr.filter(fn);
+}
+function reduceArr(arr, fn, initial) {
+  return arr.reduce(fn, initial);
+}
+function findArr(arr, fn) {
+  return arr.find(fn);
+}
+function everyArr(arr, fn) {
+  return arr.every(fn);
+}
+function someArr(arr, fn) {
+  return arr.some(fn);
+}
+function Card({ children, className = "", ...props }) {
+  return createElement("div", { className: `card ${className}`, ...props }, children);
+}
+function Btn({ children, variant = "primary", className = "", ...props }) {
+  return createElement("button", { className: `btn btn-${variant} ${className}`, ...props }, children);
+}
+function Input({ label, className = "", ...props }) {
+  return createElement(
+    "div",
+    { className: "input-wrapper" },
+    label ? createElement("label", null, label) : null,
+    createElement("input", { className: `input ${className}`, ...props })
+  );
+}
+function Modal({ open, onClose, children }) {
+  if (!open) return null;
+  return createElement(
+    "div",
+    { className: "modal-overlay", onClick: onClose },
+    createElement("div", { className: "modal-content", onClick: (e) => e.stopPropagation() }, children)
+  );
+}
+function Spinner({ size = 24 }) {
+  return createElement("div", { className: "spinner", style: { width: size, height: size } });
+}
+function Badge({ children, variant = "default" }) {
+  return createElement("span", { className: `badge badge-${variant}` }, children);
+}
+var Sigma = useStateSymbol;
+var SigmaPersist = usePersistentState;
+var sigma = useReducerSymbol;
+var bolt = useEffectSymbol;
+var swap = useFetch;
+var swapGet = useGet;
+var swapPost = usePost;
+var mem = storage;
+var memSession = sessionStore;
+var compass = nav;
+var arrMap = mapArr;
+var arrFilter = filterArr;
+var react_default = {
+  // Hooks
+  useStateSymbol,
+  usePersistentState,
+  useReducerSymbol,
+  useEffectSymbol,
+  useDebounce,
+  useInterval,
+  useFetch,
+  useGet,
+  usePost,
+  // Helpers
+  storage,
+  sessionStore,
+  nav,
+  mapArr,
+  filterArr,
+  reduceArr,
+  findArr,
+  everyArr,
+  someArr,
+  // Components
+  Card,
+  Btn,
+  Input,
+  Modal,
+  Spinner,
+  Badge,
+  // Aliases
+  Sigma,
+  SigmaPersist,
+  sigma,
+  bolt,
+  swap,
+  swapGet,
+  swapPost,
+  mem,
+  memSession,
+  compass
+};
+export {
+  Badge,
+  Btn,
+  Card,
+  Input,
+  Modal,
+  Sigma,
+  SigmaPersist,
+  Spinner,
+  arrFilter,
+  arrMap,
+  bolt,
+  compass,
+  react_default as default,
+  everyArr,
+  filterArr,
+  findArr,
+  mapArr,
+  mem,
+  memSession,
+  nav,
+  reduceArr,
+  sessionStore,
+  sigma,
+  someArr,
+  storage,
+  swap,
+  swapGet,
+  swapPost,
+  useDebounce,
+  useEffectSymbol,
+  useFetch,
+  useGet,
+  useInterval,
+  usePersistentState,
+  usePost,
+  useReducerSymbol,
+  useStateSymbol
+};

package/dist/symbols.cjs

@@ -0,0 +1,324 @@
+"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/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  ALPHABET: () => ALPHABET,
+  FALSE: () => FALSE,
+  NIL: () => NIL,
+  SYMBOLS: () => SYMBOLS,
+  TRANSPILE_MAP: () => TRANSPILE_MAP,
+  TRUE: () => TRUE,
+  VOID: () => VOID,
+  asyncFn: () => asyncFn,
+  component: () => component,
+  default: () => symbols_default,
+  effect: () => effect,
+  error: () => error,
+  filter: () => filter,
+  find: () => find,
+  fn: () => fn,
+  get: () => get,
+  log: () => log,
+  map: () => map,
+  navigate: () => navigate,
+  post: () => post,
+  reduce: () => reduce,
+  shape: () => shape,
+  state: () => state,
+  storageGet: () => storageGet,
+  storageSet: () => storageSet,
+  toSymbolic: () => toSymbolic,
+  transpileSymbols: () => transpileSymbols,
+  validate: () => validate
+});
+module.exports = __toCommonJS(symbols_exports);
+var TRUE = true;
+var FALSE = false;
+var VOID = null;
+var NIL = void 0;
+var SYMBOLS = {
+  STATE: "\u03A3",
+  SUBSTATE: "\u03C3",
+  VOID: "\xD8",
+  TRUE: "\u22A4",
+  FALSE: "\u22A5",
+  LOCK: "\u{1F512}",
+  UNLOCK: "\u{1F513}",
+  STRING: "\u{1D54A}",
+  INTEGER: "\u2124",
+  REAL: "\u211D",
+  BOOLEAN: "\u{1D539}",
+  ARRAY: "\u{1D538}",
+  OBJECT: "\u{1D546}",
+  FUNCTION: "\u03BB",
+  PROMISE: "\u2119",
+  ANY: "\u229B",
+  NULL: "\u2205",
+  SHAPE: "\u25A0",
+  CLASS: "\u25CB",
+  INSTANCE: "\u25CF",
+  MODULE: "\u29C9",
+  FN: "\u0192",
+  LAMBDA: "\u03BB",
+  ASYNC: "\u03BB\u21C4",
+  MEMO: "\u03BB+",
+  ACTION: "\u0394",
+  EXEC: "\u2192",
+  IMPLIES: "\u21D2",
+  PARALLEL: "\u21C9",
+  ASSIGN: "\u2190",
+  DERIVE: "\u21D0",
+  NOT_EQUAL: "\u2260",
+  LTE: "\u2264",
+  GTE: "\u2265",
+  AND: "\u2227",
+  OR: "\u2228",
+  NOT: "\xAC",
+  MULT: "\xD7",
+  DIV: "\xF7",
+  MERGE: "\u2295",
+  IN: "\u2208",
+  UNION: "\u222A",
+  MAP: "\u21A6",
+  FILTER: "\u22B3",
+  REDUCE: "\u22B2",
+  FIND: "\u2299",
+  EVERY: "\u2200",
+  SOME: "\u2203",
+  EFFECT: "\u26A1",
+  EVENT: "\u25CC",
+  AWAIT: "\u21C4",
+  GET: "\u21C4 GET",
+  POST: "\u21C4 POST",
+  MEMORY: "\u{1D4DC}",
+  ROUTE: "\u{1F9ED}",
+  NAVIGATE: "\u{1F9ED}\u2192",
+  COMPONENT: "\u2610",
+  JSX_OPEN: "\u27E8",
+  JSX_CLOSE: "\u27E9",
+  PAGE: "\u2610.page",
+  CARD: "\u2610.card",
+  BTN: "\u2610.btn",
+  INPUT: "\u2610.input",
+  MODAL: "\u2610.modal",
+  SPINNER: "\u2610.spinner",
+  SECURITY: "\u{1F6E1}",
+  VALIDATE: "\u{1F6E1}!",
+  KEY: "\u{1F511}",
+  EVOLVE: "\u27F3",
+  AI: "\u03A8",
+  LOG: "\u{1F4DC}",
+  INTERVAL: "\u21BB",
+  IMPORT: "\u29C9",
+  EXPORT: "\u2191"
+};
+var TRANSPILE_MAP = {
+  "\u03A3[": "const [",
+  "\xD8": "null",
+  "\u22A4": "true",
+  "\u22A5": "false",
+  "\u{1D54A}": "string",
+  "\u2124": "number",
+  "\u211D": "number",
+  "\u{1D539}": "boolean",
+  "\u{1D538}": "Array",
+  "\u{1D546}": "object",
+  "\u03BB": "() =>",
+  "\u2119": "Promise",
+  "\u25A0": "interface",
+  "\u25CB": "class",
+  "\u25CF": "new",
+  "\u0192": "function",
+  "\u2192": "=>",
+  "\u21D2": "?",
+  "\u21C9": "Promise.all",
+  "\u2190": "=",
+  "\u2260": "!==",
+  "\u2264": "<=",
+  "\u2265": ">=",
+  "\u2227": "&&",
+  "\u2228": "||",
+  "\xAC": "!",
+  "\xD7": "*",
+  "\xF7": "/",
+  "\u21A6": ".map(",
+  "\u22B3": ".filter(",
+  "\u22B2": ".reduce(",
+  "\u2299": ".find(",
+  "\u2200": ".every(",
+  "\u2203": ".some(",
+  "\u26A1[]": "useEffect(() => {",
+  "\u25CC.click": "onClick",
+  "\u25CC.change": "onChange",
+  "\u25CC.submit": "onSubmit",
+  "\u21C4": "await",
+  "\u21C4 GET": "await fetch(",
+  "\u{1D4DC}[": "localStorage.getItem(",
+  "\u{1D4DC}\u2190": "localStorage.setItem(",
+  "\u{1F9ED}\u2192": "navigate(",
+  "\u2610": "function Component",
+  "\u27E8": "<",
+  "\u27E9": ">",
+  "\u{1F4DC}": "console.log(",
+  "\u26D4": "throw new Error(",
+  "\u21BB": "setInterval("
+};
+function transpileSymbols(code) {
+  let result = code;
+  const sortedKeys = Object.keys(TRANSPILE_MAP).sort((a, b) => b.length - a.length);
+  for (const symbol of sortedKeys) {
+    result = result.split(symbol).join(TRANSPILE_MAP[symbol]);
+  }
+  return result;
+}
+function toSymbolic(code) {
+  let result = code;
+  const inverseMap = {};
+  for (const [symbol, js] of Object.entries(TRANSPILE_MAP)) {
+    inverseMap[js] = symbol;
+  }
+  const sortedKeys = Object.keys(inverseMap).sort((a, b) => b.length - a.length);
+  for (const js of sortedKeys) {
+    result = result.split(js).join(inverseMap[js]);
+  }
+  return result;
+}
+var state = (name, initial) => `const [${name}, set${name.charAt(0).toUpperCase() + name.slice(1)}] = useState(${JSON.stringify(initial)});`;
+var effect = (body, deps = []) => `useEffect(() => { ${body} }, [${deps.join(", ")}]);`;
+var fn = (name, params, body) => `function ${name}(${params.join(", ")}) { ${body} }`;
+var asyncFn = (name, params, body) => `async function ${name}(${params.join(", ")}) { ${body} }`;
+var component = (name, body) => `function ${name}() { ${body} }`;
+var shape = (name, fields) => {
+  const fieldStrs = Object.entries(fields).map(([k, v]) => `  ${k}: ${v};`).join("\n");
+  return `interface ${name} {
+${fieldStrs}
+}`;
+};
+var get = (url) => `await fetch(${JSON.stringify(url)}).then(r => r.json())`;
+var post = (url, body) => `await fetch(${JSON.stringify(url)}, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(${body}) }).then(r => r.json())`;
+var navigate = (path) => `navigate(${JSON.stringify(path)})`;
+var map = (arr, cb) => `${arr}.map(${cb})`;
+var filter = (arr, pred) => `${arr}.filter(${pred})`;
+var reduce = (arr, red, init) => `${arr}.reduce(${red}, ${init})`;
+var find = (arr, pred) => `${arr}.find(${pred})`;
+var storageGet = (key) => `localStorage.getItem(${JSON.stringify(key)})`;
+var storageSet = (key, val) => `localStorage.setItem(${JSON.stringify(key)}, JSON.stringify(${val}))`;
+var validate = (schema, data) => `validate(${schema}, ${data})`;
+var log = (msg) => `console.log(${msg})`;
+var error = (msg) => `throw new Error(${JSON.stringify(msg)})`;
+var ALPHABET = {
+  STATE: { symbol: "\u03A3", js: "useState", desc: "Estado global" },
+  SUBSTATE: { symbol: "\u03C3", js: "localState", desc: "Estado local" },
+  VOID: { symbol: "\xD8", js: "null", desc: "N\xE3o-exist\xEAncia" },
+  TRUE: { symbol: "\u22A4", js: "true", desc: "Verdadeiro" },
+  FALSE: { symbol: "\u22A5", js: "false", desc: "Falso" },
+  STRING: { symbol: "\u{1D54A}", js: "string", desc: "Texto" },
+  INTEGER: { symbol: "\u2124", js: "number", desc: "Inteiro" },
+  REAL: { symbol: "\u211D", js: "number", desc: "Real" },
+  BOOLEAN: { symbol: "\u{1D539}", js: "boolean", desc: "Booleano" },
+  ARRAY: { symbol: "\u{1D538}", js: "Array", desc: "Lista" },
+  OBJECT: { symbol: "\u{1D546}", js: "object", desc: "Objeto" },
+  FUNCTION: { symbol: "\u03BB", js: "() =>", desc: "Fun\xE7\xE3o" },
+  FN: { symbol: "\u0192", js: "function", desc: "Fun\xE7\xE3o nomeada" },
+  SHAPE: { symbol: "\u25A0", js: "interface", desc: "Interface" },
+  CLASS: { symbol: "\u25CB", js: "class", desc: "Classe" },
+  INSTANCE: { symbol: "\u25CF", js: "new", desc: "Inst\xE2ncia" },
+  EXEC: { symbol: "\u2192", js: "=>", desc: "Execu\xE7\xE3o" },
+  ASSIGN: { symbol: "\u2190", js: "=", desc: "Atribui\xE7\xE3o" },
+  AND: { symbol: "\u2227", js: "&&", desc: "E l\xF3gico" },
+  OR: { symbol: "\u2228", js: "||", desc: "Ou l\xF3gico" },
+  NOT: { symbol: "\xAC", js: "!", desc: "Nega\xE7\xE3o" },
+  MAP: { symbol: "\u21A6", js: ".map", desc: "Mapear" },
+  FILTER: { symbol: "\u22B3", js: ".filter", desc: "Filtrar" },
+  REDUCE: { symbol: "\u22B2", js: ".reduce", desc: "Reduzir" },
+  FIND: { symbol: "\u2299", js: ".find", desc: "Encontrar" },
+  EFFECT: { symbol: "\u26A1", js: "useEffect", desc: "Efeito" },
+  EVENT: { symbol: "\u25CC", js: "on", desc: "Evento" },
+  AWAIT: { symbol: "\u21C4", js: "await", desc: "Async" },
+  MEMORY: { symbol: "\u{1D4DC}", js: "localStorage", desc: "Storage" },
+  ROUTE: { symbol: "\u{1F9ED}", js: "router", desc: "Rota" },
+  NAVIGATE: { symbol: "\u{1F9ED}\u2192", js: "navigate", desc: "Navegar" },
+  COMPONENT: { symbol: "\u2610", js: "function", desc: "Componente" },
+  SECURITY: { symbol: "\u{1F6E1}", js: "security", desc: "Seguran\xE7a" },
+  EVOLVE: { symbol: "\u27F3", js: "evolve", desc: "Evoluir" },
+  AI: { symbol: "\u03A8", js: "ai", desc: "IA" },
+  LOG: { symbol: "\u{1F4DC}", js: "console.log", desc: "Log" },
+  INTERVAL: { symbol: "\u21BB", js: "setInterval", desc: "Intervalo" }
+};
+var symbols_default = {
+  SYMBOLS,
+  ALPHABET,
+  TRANSPILE_MAP,
+  transpileSymbols,
+  toSymbolic,
+  state,
+  effect,
+  fn,
+  asyncFn,
+  component,
+  shape,
+  get,
+  post,
+  navigate,
+  map,
+  filter,
+  reduce,
+  find,
+  storageGet,
+  storageSet,
+  validate,
+  log,
+  error,
+  TRUE,
+  FALSE,
+  VOID,
+  NIL
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALPHABET,
+  FALSE,
+  NIL,
+  SYMBOLS,
+  TRANSPILE_MAP,
+  TRUE,
+  VOID,
+  asyncFn,
+  component,
+  effect,
+  error,
+  filter,
+  find,
+  fn,
+  get,
+  log,
+  map,
+  navigate,
+  post,
+  reduce,
+  shape,
+  state,
+  storageGet,
+  storageSet,
+  toSymbolic,
+  transpileSymbols,
+  validate
+});