lf-pagebuilder-vue 0.0.15 → 0.0.16

package/dist/limbo/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Limbo Integration Module
+ *
+ * Re-exporta las utilidades de Limbo desde lf-pagebuilder-vue.
+ * El portal consumidor importa desde aquí:
+ *
+ * import { createLimboTokenHandler } from 'lf-pagebuilder-vue/limbo';
+ */
+export { createLimboTokenHandler, LIMBO_API_URLS, LIMBO_ENV_VARS, type LimboTokenConfig, type LimboTokenResponse, } from './tokenHandler';
+export { default } from './tokenHandler';

package/dist/limbo/tokenHandler.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Limbo Token Handler
+ *
+ * Handler genérico para obtener tokens JWT de Limbo.
+ * Framework-agnostic: funciona en Astro, Next.js, Express, etc.
+ *
+ * La URL de la API de Limbo se determina automáticamente según `isProduction`:
+ * - Producción: https://limbo.lefebvre.es
+ * - Desarrollo: https://led-dev-limbo-dev.eu.els.local
+ *
+ * @example Astro
+ * ```ts
+ * // src/pages/api/limbo-token.ts
+ * import { createLimboTokenHandler } from 'lf-pagebuilder-vue/limbo';
+ *
+ * export const POST = createLimboTokenHandler({
+ *   publicKey: import.meta.env.PUBLIC_LIMBO_PUBLIC_KEY,
+ *   isProduction: import.meta.env.IS_PROD === 'TRUE'
+ * });
+ * ```
+ *
+ * @example Next.js App Router
+ * ```ts
+ * // app/api/limbo-token/route.ts
+ * import { createLimboTokenHandler } from 'lf-pagebuilder-vue/limbo';
+ *
+ * export const POST = createLimboTokenHandler({
+ *   publicKey: process.env.PUBLIC_LIMBO_PUBLIC_KEY!,
+ *   isProduction: process.env.NODE_ENV === 'production'
+ * });
+ * ```
+ */
+/** URLs por defecto de la API de Limbo */
+declare const LIMBO_API_URLS: {
+    readonly production: "https://limbo.lefebvre.es";
+    readonly development: "https://led-dev-limbo-dev.eu.els.local";
+};
+export interface LimboTokenConfig {
+    /** Public Key del portal de Limbo (pk_xxx) */
+    publicKey: string;
+    /** ¿Usar API de producción? (default: false = desarrollo) */
+    isProduction?: boolean;
+    /** URL base de la API de Limbo (opcional, se determina por isProduction si no se especifica) */
+    limboApiUrl?: string;
+    /** Permitir override de publicKey desde el body de la request (default: true) */
+    allowPublicKeyOverride?: boolean;
+}
+export interface LimboTokenResponse {
+    success: boolean;
+    token?: string;
+    expires_in?: number;
+    error?: string;
+    details?: string;
+    hint?: string;
+}
+/**
+ * Crea un handler para obtener tokens JWT de Limbo.
+ *
+ * Este handler actúa como proxy para evitar problemas de CORS,
+ * haciendo la petición a Limbo desde el servidor.
+ *
+ * @param config - Configuración con publicKey e isProduction
+ * @returns Handler compatible con Astro, Next.js, y otros frameworks
+ */
+export declare function createLimboTokenHandler(config: LimboTokenConfig): ({ request }: {
+    request: Request;
+}) => Promise<Response>;
+/**
+ * URLs por defecto de la API de Limbo (exportadas para referencia).
+ */
+export { LIMBO_API_URLS };
+/**
+ * Variables de entorno necesarias.
+ */
+export declare const LIMBO_ENV_VARS: {
+    /** Variable de entorno para la Public Key (con prefijo PUBLIC_ para cliente) */
+    readonly PUBLIC_KEY: "PUBLIC_LIMBO_PUBLIC_KEY";
+    /** Variable de entorno para indicar si es producción */
+    readonly IS_PROD: "IS_PROD";
+};
+export default createLimboTokenHandler;

package/dist/limbo.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const t={production:"https://limbo.lefebvre.es",development:"https://led-dev-limbo-dev.eu.els.local"};function l(c){const{publicKey:n,isProduction:i=!1,limboApiUrl:u,allowPublicKeyOverride:p=!0}=c,a=u||(i?t.production:t.development);return n||console.error("[Limbo Token Handler] PUBLIC_LIMBO_PUBLIC_KEY no está configurada"),console.log(`[Limbo Token Handler] Configurado para ${i?"PRODUCCIÓN":"DESARROLLO"}: ${a}`),async function({request:d}){try{let e=n;if(p)try{const r=await d.json();r.public_key&&(e=r.public_key)}catch{}if(!e)return new Response(JSON.stringify({success:!1,error:"PUBLIC_LIMBO_PUBLIC_KEY no configurada"}),{status:400,headers:{"Content-Type":"application/json"}});const o=`${a}/auth/token`;console.log("[Limbo Proxy] Requesting token from:",o),console.log("[Limbo Proxy] Using public_key:",e.substring(0,10)+"...");const s=await fetch(o,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({public_key:e})});if(!s.ok){const r=await s.text();return console.error("[Limbo Proxy] Error response:",s.status,r),new Response(JSON.stringify({success:!1,error:`API error: ${s.status}`,details:r}),{status:s.status,headers:{"Content-Type":"application/json"}})}const f=await s.json();return console.log("[Limbo Proxy] Token obtained successfully"),new Response(JSON.stringify(f),{status:200,headers:{"Content-Type":"application/json"}})}catch(e){console.error("[Limbo Proxy] Error completo:",e);let o="Unknown error";return e instanceof Error&&(o=e.message,"cause"in e&&e.cause&&(o+=` (cause: ${JSON.stringify(e.cause)})`)),new Response(JSON.stringify({success:!1,error:o,hint:"Verifica que la API de Limbo sea accesible desde el servidor"}),{status:500,headers:{"Content-Type":"application/json"}})}}}const y={PUBLIC_KEY:"PUBLIC_LIMBO_PUBLIC_KEY",IS_PROD:"IS_PROD"};exports.LIMBO_API_URLS=t;exports.LIMBO_ENV_VARS=y;exports.createLimboTokenHandler=l;exports.default=l;

package/dist/limbo.d.ts

@@ -0,0 +1,3 @@
+export * from './limbo/index'
+import _default from './limbo/index'
+export default _default

package/dist/limbo.js

@@ -0,0 +1,90 @@
+const a = {
+  production: "https://limbo.lefebvre.es",
+  development: "https://led-dev-limbo-dev.eu.els.local"
+};
+function y(c) {
+  const {
+    publicKey: n,
+    isProduction: t = !1,
+    limboApiUrl: l,
+    allowPublicKeyOverride: u = !0
+  } = c, i = l || (t ? a.production : a.development);
+  return n || console.error("[Limbo Token Handler] PUBLIC_LIMBO_PUBLIC_KEY no está configurada"), console.log(`[Limbo Token Handler] Configurado para ${t ? "PRODUCCIÓN" : "DESARROLLO"}: ${i}`), async function({ request: p }) {
+    try {
+      let e = n;
+      if (u)
+        try {
+          const r = await p.json();
+          r.public_key && (e = r.public_key);
+        } catch {
+        }
+      if (!e)
+        return new Response(
+          JSON.stringify({
+            success: !1,
+            error: "PUBLIC_LIMBO_PUBLIC_KEY no configurada"
+          }),
+          {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      const o = `${i}/auth/token`;
+      console.log("[Limbo Proxy] Requesting token from:", o), console.log("[Limbo Proxy] Using public_key:", e.substring(0, 10) + "...");
+      const s = await fetch(o, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          public_key: e
+        })
+      });
+      if (!s.ok) {
+        const r = await s.text();
+        return console.error("[Limbo Proxy] Error response:", s.status, r), new Response(
+          JSON.stringify({
+            success: !1,
+            error: `API error: ${s.status}`,
+            details: r
+          }),
+          {
+            status: s.status,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      const d = await s.json();
+      return console.log("[Limbo Proxy] Token obtained successfully"), new Response(JSON.stringify(d), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (e) {
+      console.error("[Limbo Proxy] Error completo:", e);
+      let o = "Unknown error";
+      return e instanceof Error && (o = e.message, "cause" in e && e.cause && (o += ` (cause: ${JSON.stringify(e.cause)})`)), new Response(
+        JSON.stringify({
+          success: !1,
+          error: o,
+          hint: "Verifica que la API de Limbo sea accesible desde el servidor"
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+const b = {
+  /** Variable de entorno para la Public Key (con prefijo PUBLIC_ para cliente) */
+  PUBLIC_KEY: "PUBLIC_LIMBO_PUBLIC_KEY",
+  /** Variable de entorno para indicar si es producción */
+  IS_PROD: "IS_PROD"
+};
+export {
+  a as LIMBO_API_URLS,
+  b as LIMBO_ENV_VARS,
+  y as createLimboTokenHandler,
+  y as default
+};

package/dist/mocks/libreria-astro-lefebvre.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Mock de libreria-astro-lefebvre para el build de Symfony
+ *
+ * Los componentes se pueden inyectar de dos formas:
+ * 1. Definiendo window.LF_PAGEBUILDER_COMPONENTS antes de cargar el script
+ * 2. Usando LfPagebuilder.setComponents(componentes) después de cargar
+ *
+ * Ejemplo de uso en Twig/Symfony:
+ * <script>
+ *   window.LF_PAGEBUILDER_COMPONENTS = {
+ *     "hero-banner": {
+ *       name: "Hero Banner",
+ *       component_name: "HeroBanner",
+ *       description: "Banner principal",
+ *       category: "Cabecera",
+ *       framework: "Astro",
+ *       tags: ["hero", "banner"],
+ *       fields: [
+ *         { name: "title", label: "Título", type: "text", mandatory: true }
+ *       ]
+ *     }
+ *   };
+ * </script>
+ * <script src="lf-pagebuilder-iife.js"></script>
+ */
+interface ComponentField {
+    name: string;
+    label: string;
+    type: 'text' | 'textArea' | 'image' | 'select' | 'boolean';
+    mandatory?: boolean;
+    example_value?: string | boolean;
+    options?: string[];
+    image_cuts?: {
+        width: number;
+        height: number;
+        label: string;
+        required?: boolean;
+    }[];
+    mappedTo?: string;
+}
+interface PageComponent {
+    id?: string;
+    name: string;
+    component_name: string;
+    description: string;
+    category: string;
+    framework: string;
+    tags: string[];
+    fields: ComponentField[];
+    repeat_data?: any;
+}
+type ComponentsRegistry = Record<string, PageComponent>;
+/**
+ * Retorna la lista de componentes disponibles
+ * Primero busca en window.LF_PAGEBUILDER_COMPONENTS, si no existe usa los por defecto
+ */
+export declare function listComponents(): ComponentsRegistry;
+/**
+ * Permite establecer los componentes dinámicamente
+ * Útil para cargarlos vía AJAX después de que la página cargue
+ */
+export declare function setComponents(components: ComponentsRegistry): void;
+/**
+ * Añade un componente al registro
+ */
+export declare function addComponent(key: string, component: PageComponent): void;
+/**
+ * Obtiene los componentes por defecto
+ */
+export declare function getDefaultComponents(): ComponentsRegistry;
+declare const _default: {
+    listComponents: typeof listComponents;
+    setComponents: typeof setComponents;
+    addComponent: typeof addComponent;
+    getDefaultComponents: typeof getDefaultComponents;
+};
+export default _default;

package/dist/symfony-entry.d.ts

@@ -0,0 +1,29 @@
+import { createApp } from 'vue';
+import { setComponents, addComponent, getDefaultComponents, listComponents } from './mocks/libreria-astro-lefebvre';
+
+interface PagebuilderInstance {
+    app: ReturnType<typeof createApp>;
+    container: HTMLElement;
+    input: HTMLInputElement;
+    unmount: () => void;
+}
+interface LfPagebuilderConfig {
+    isProduction?: boolean;
+    selector?: string;
+    onReady?: (instance: PagebuilderInstance) => void;
+    onChange?: (config: any, input: HTMLInputElement) => void;
+}
+/**
+ * Inicializa el Pagebuilder en todos los elementos que coincidan con el selector
+ */
+declare function init(config?: LfPagebuilderConfig): PagebuilderInstance[];
+/**
+ * Destruye todas las instancias del Pagebuilder
+ */
+declare function destroyAll(): void;
+/**
+ * Obtiene todas las instancias activas
+ */
+declare function getInstances(): PagebuilderInstance[];
+export { init, destroyAll, getInstances, setComponents, addComponent, getDefaultComponents, listComponents };
+export type { PagebuilderInstance, LfPagebuilderConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lf-pagebuilder-vue",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Constructor de páginas visual basado en Vue.js que permite crear y diseñar páginas web de forma intuitiva mediante componentes arrastrables y configurables",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -12,6 +12,11 @@
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     },
+    "./limbo": {
+      "import": "./dist/limbo.js",
+      "require": "./dist/limbo.cjs",
+      "types": "./dist/limbo.d.ts"
+    },
     "./styles": "./dist/styles.css"
   },
   "files": [
@@ -26,9 +31,12 @@
     "build:symfony": "vite build --config vite.config.symfony.ts",
     "build:all": "npm run build && npm run build:symfony"
   },
+  "dependencies": {
+    "libreria-astro-lefebvre": "latest",
+    "limbo-component": "latest"
+  },
   "peerDependencies": {
     "@vueup/vue-quill": "^1.2.0",
-    "libreria-astro-lefebvre": "latest",
     "vue": "^3.3.0",
     "vuedraggable": "^4.1.0"
   },