veleta-templates 0.0.20 → 0.0.22

package/dist/components/index.d.ts

@@ -31,3 +31,5 @@ export interface SetPlatformOptions {
   rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
 }
 export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;
+
+export * from '../types';

package/dist/components/{veleta-umami-template.d.ts → veleta-menu-tabs.d.ts}

@@ -1,9 +1,9 @@
 import type { Components, JSX } from "../types/components";
 
-interface VeletaUmamiTemplate extends Components.VeletaUmamiTemplate, HTMLElement {}
-export const VeletaUmamiTemplate: {
-    prototype: VeletaUmamiTemplate;
-    new (): VeletaUmamiTemplate;
+interface VeletaMenuTabs extends Components.VeletaMenuTabs, HTMLElement {}
+export const VeletaMenuTabs: {
+    prototype: VeletaMenuTabs;
+    new (): VeletaMenuTabs;
 };
 /**
  * Used to define this component and all nested components recursively.

package/dist/types/components/default-template/components/menu-tabs/menu-tabs.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '../../../../stencil-public-runtime';
+export declare class MenuTabs {
+    el: HTMLElement;
+    sections: {
+        id: string;
+        title: string;
+    }[];
+    activeSectionId: string;
+    tabClick: EventEmitter<string>;
+    handleActiveSectionChange(): void;
+    componentDidLoad(): void;
+    private scrollToActiveTab;
+    render(): any;
+}

package/dist/types/components/default-template/default-template.d.ts

@@ -2,8 +2,18 @@ import { Menu } from '../../types/interfaces';
 export declare class DefaultTemplate {
     el: HTMLElement;
     expandedDishes: Record<string, boolean>;
-    searchQuery: string;
+    activeSectionId: string;
+    private sectionVisibility;
+    private isScrollingByTab;
+    private scrollTimeout;
+    private observer;
     private toggleDish;
+    private handleTabClick;
+    componentDidLoad(): void;
+    private handleScroll;
+    private updateActiveSection;
+    disconnectedCallback(): void;
+    private initIntersectionObserver;
     /**
      * Menu data as object (recommended for frameworks like Angular, React, Vue)
      */

package/dist/types/components.d.ts

@@ -19,19 +19,21 @@ export namespace Components {
          */
         "dataJson": string;
     }
-    interface VeletaUmamiTemplate {
+    interface VeletaMenuTabs {
         /**
-          * Menu data as object (recommended for frameworks like Angular, React, Vue) This takes precedence over dataJson if both are provided
+          * @default ''
          */
-        "data"?: Menu;
+        "activeSectionId": string;
         /**
-          * Menu data as JSON string (for compatibility with HTML attributes)
-          * @deprecated Use `data` prop instead for better type safety
-          * @default '{}'
+          * @default []
          */
-        "dataJson": string;
+        "sections": { id: string; title: string }[];
     }
 }
+export interface VeletaMenuTabsCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLVeletaMenuTabsElement;
+}
 declare global {
     interface HTMLVeletaDefaultTemplateElement extends Components.VeletaDefaultTemplate, HTMLStencilElement {
     }
@@ -39,15 +41,26 @@ declare global {
         prototype: HTMLVeletaDefaultTemplateElement;
         new (): HTMLVeletaDefaultTemplateElement;
     };
-    interface HTMLVeletaUmamiTemplateElement extends Components.VeletaUmamiTemplate, HTMLStencilElement {
+    interface HTMLVeletaMenuTabsElementEventMap {
+        "tabClick": string;
+    }
+    interface HTMLVeletaMenuTabsElement extends Components.VeletaMenuTabs, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLVeletaMenuTabsElementEventMap>(type: K, listener: (this: HTMLVeletaMenuTabsElement, ev: VeletaMenuTabsCustomEvent<HTMLVeletaMenuTabsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLVeletaMenuTabsElementEventMap>(type: K, listener: (this: HTMLVeletaMenuTabsElement, ev: VeletaMenuTabsCustomEvent<HTMLVeletaMenuTabsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
-    var HTMLVeletaUmamiTemplateElement: {
-        prototype: HTMLVeletaUmamiTemplateElement;
-        new (): HTMLVeletaUmamiTemplateElement;
+    var HTMLVeletaMenuTabsElement: {
+        prototype: HTMLVeletaMenuTabsElement;
+        new (): HTMLVeletaMenuTabsElement;
     };
     interface HTMLElementTagNameMap {
         "veleta-default-template": HTMLVeletaDefaultTemplateElement;
-        "veleta-umami-template": HTMLVeletaUmamiTemplateElement;
+        "veleta-menu-tabs": HTMLVeletaMenuTabsElement;
     }
 }
 declare namespace LocalJSX {
@@ -62,29 +75,36 @@ declare namespace LocalJSX {
          */
         "dataJson"?: string;
     }
-    interface VeletaUmamiTemplate {
+    interface VeletaMenuTabs {
         /**
-          * Menu data as object (recommended for frameworks like Angular, React, Vue) This takes precedence over dataJson if both are provided
+          * @default ''
          */
-        "data"?: Menu;
+        "activeSectionId"?: string;
+        "onTabClick"?: (event: VeletaMenuTabsCustomEvent<string>) => void;
         /**
-          * Menu data as JSON string (for compatibility with HTML attributes)
-          * @deprecated Use `data` prop instead for better type safety
-          * @default '{}'
+          * @default []
          */
-        "dataJson"?: string;
+        "sections"?: { id: string; title: string }[];
+    }
+
+    interface VeletaDefaultTemplateAttributes {
+        "dataJson": string;
+    }
+    interface VeletaMenuTabsAttributes {
+        "activeSectionId": string;
     }
+
     interface IntrinsicElements {
-        "veleta-default-template": VeletaDefaultTemplate;
-        "veleta-umami-template": VeletaUmamiTemplate;
+        "veleta-default-template": Omit<VeletaDefaultTemplate, keyof VeletaDefaultTemplateAttributes> & { [K in keyof VeletaDefaultTemplate & keyof VeletaDefaultTemplateAttributes]?: VeletaDefaultTemplate[K] } & { [K in keyof VeletaDefaultTemplate & keyof VeletaDefaultTemplateAttributes as `attr:${K}`]?: VeletaDefaultTemplateAttributes[K] } & { [K in keyof VeletaDefaultTemplate & keyof VeletaDefaultTemplateAttributes as `prop:${K}`]?: VeletaDefaultTemplate[K] };
+        "veleta-menu-tabs": Omit<VeletaMenuTabs, keyof VeletaMenuTabsAttributes> & { [K in keyof VeletaMenuTabs & keyof VeletaMenuTabsAttributes]?: VeletaMenuTabs[K] } & { [K in keyof VeletaMenuTabs & keyof VeletaMenuTabsAttributes as `attr:${K}`]?: VeletaMenuTabsAttributes[K] } & { [K in keyof VeletaMenuTabs & keyof VeletaMenuTabsAttributes as `prop:${K}`]?: VeletaMenuTabs[K] };
     }
 }
 export { LocalJSX as JSX };
 declare module "@stencil/core" {
     export namespace JSX {
         interface IntrinsicElements {
-            "veleta-default-template": LocalJSX.VeletaDefaultTemplate & JSXBase.HTMLAttributes<HTMLVeletaDefaultTemplateElement>;
-            "veleta-umami-template": LocalJSX.VeletaUmamiTemplate & JSXBase.HTMLAttributes<HTMLVeletaUmamiTemplateElement>;
+            "veleta-default-template": LocalJSX.IntrinsicElements["veleta-default-template"] & JSXBase.HTMLAttributes<HTMLVeletaDefaultTemplateElement>;
+            "veleta-menu-tabs": LocalJSX.IntrinsicElements["veleta-menu-tabs"] & JSXBase.HTMLAttributes<HTMLVeletaMenuTabsElement>;
         }
     }
 }

package/dist/types/stencil-public-runtime.d.ts

@@ -63,6 +63,12 @@ export interface ShadowRootOptions {
      * focusable part is given focus, and the shadow host is given any available `:focus` styling.
      */
     delegatesFocus?: boolean;
+    /**
+     * Sets the slot assignment mode for the shadow root. When set to `'manual'`, enables imperative
+     * slotting using the `HTMLSlotElement.assign()` method. Defaults to `'named'` for standard
+     * declarative slotting behavior.
+     */
+    slotAssignment?: 'manual' | 'named';
 }
 export interface ModeStyles {
     [modeName: string]: string | string[];
@@ -119,8 +125,27 @@ export interface EventOptions {
      */
     composed?: boolean;
 }
+export interface AttachInternalsOptions {
+    /**
+     * Initial custom states to set on the ElementInternals.states CustomStateSet.
+     * Each key is the state name and the value is the initial boolean state.
+     *
+     * These states can be targeted with the CSS `:state()` pseudo-class.
+     *
+     * @example
+     * ```tsx
+     * @AttachInternals({ states: { open: true, active: false } })
+     * internals: ElementInternals;
+     * ```
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+     */
+    states?: {
+        [stateName: string]: boolean;
+    };
+}
 export interface AttachInternalsDecorator {
-    (): PropertyDecorator;
+    (opts?: AttachInternalsOptions): PropertyDecorator;
 }
 export interface ListenDecorator {
     (eventName: string, opts?: ListenOptions): CustomMethodDecorator<any>;
@@ -156,7 +181,9 @@ export interface StateDecorator {
     (): PropertyDecorator;
 }
 export interface WatchDecorator {
-    (propName: any): CustomMethodDecorator<(newValue?: any, oldValue?: any, propName?: any, ...args: any[]) => any | void>;
+    (propName: any, watchOptions?: {
+        immediate?: boolean;
+    }): CustomMethodDecorator<(newValue?: any, oldValue?: any, propName?: any, ...args: any[]) => any | void>;
 }
 export interface PropSerializeDecorator {
     (propName: any): CustomMethodDecorator<(newValue?: any, propName?: string, ...args: any[]) => string | null>;
@@ -610,7 +637,7 @@ export interface FunctionalUtilities {
     map: (children: VNode[], cb: (vnode: ChildNode, index: number, array: ChildNode[]) => ChildNode) => VNode[];
 }
 export interface FunctionalComponent<T = {}> {
-    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[];
+    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[] | null;
 }
 /**
  * A Child VDOM node
@@ -652,6 +679,7 @@ export declare namespace h {
     function h(sel: any, data: VNodeData | null, text: string): VNode;
     function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
     function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+    function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
     namespace JSX {
         interface IntrinsicElements extends LocalJSX.IntrinsicElements, JSXBase.IntrinsicElements {
             [tagName: string]: any;
@@ -666,6 +694,36 @@ export declare function h(sel: any, children: Array<VNode | undefined | null>):
 export declare function h(sel: any, data: VNodeData | null, text: string): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+export declare function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsx mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsx".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxmode with multiple children.
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsxs(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxdev mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsxdev".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @param isStaticChildren indicates if the children are static
+ * @param source source information
+ * @param self reference to the component instance
+ * @returns a jsx vnode
+ */
+export declare function jsxDEV(type: any, props: any, key?: string | number, isStaticChildren?: boolean, source?: any, self?: any): VNode;
 /**
  * A virtual DOM node
  */
@@ -695,7 +753,7 @@ declare namespace LocalJSX {
 export { LocalJSX as JSX };
 export declare namespace JSXBase {
     interface IntrinsicElements {
-        slot: JSXBase.SlotAttributes;
+        slot: JSXBase.SlotAttributes<HTMLSlotElement>;
         a: JSXBase.AnchorHTMLAttributes<HTMLAnchorElement>;
         abbr: JSXBase.HTMLAttributes;
         address: JSXBase.HTMLAttributes;
@@ -865,7 +923,7 @@ export declare namespace JSXBase {
         use: JSXBase.SVGAttributes;
         view: JSXBase.SVGAttributes;
     }
-    interface SlotAttributes extends JSXAttributes {
+    interface SlotAttributes<T = HTMLSlotElement> extends JSXAttributes<T> {
         name?: string;
         slot?: string;
         onSlotchange?: (event: Event) => void;
@@ -921,6 +979,9 @@ export declare namespace JSXBase {
         popoverTargetAction?: string;
         popoverTargetElement?: Element | null;
         popoverTarget?: string;
+        command?: string;
+        commandFor?: string;
+        commandfor?: string;
     }
     interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
         height?: number | string;

package/dist/types/types/interfaces.d.ts

@@ -25,6 +25,7 @@ export interface MenuInfo {
     name: string;
     slug: string;
     active: boolean;
+    description?: string;
 }
 export interface BusinessInfo {
     name: string;

package/dist/types/utils/prop-parser.d.ts

@@ -9,3 +9,7 @@ export declare function parseList<T>(json: string | T[]): T[];
  * Compatible con Angular/Ionic (objetos directos) y Astro/vanilla JS (strings JSON).
  */
 export declare function parseTheme(themeJson: string | Theme): Theme | null;
+/**
+ * Parsea los props de un menú (objeto directo o string JSON).
+ */
+export declare function parseMenu(data?: any, dataJson?: string): any;