Accordion
Accordion alkalmazása
x-pds.accordion
titleopendisabled
Ha több accordiont szeretnél használni, egyszerűen egymás után rakd őket.
title - Az accordion fejléce (string, kötelező). A header automatikusan ds-heading-3 tipográfiát kap.open - Boolean, kezdeti állapot (default: false, csukva).disabled - Boolean, letiltja az elemet (default: false). Disabled elem nem nyitható meg, opacity: 0.5.
Slot:
A
$slot tartalmazza a fő tartalmat (accordion body), amely automatikusan ds-body-2 tipográfiát és tertiary színt kap.
Funkciók:
- Független accordion elemek (több elem is nyitva lehet egyszerre)
- Smooth CSS Grid animáció height változáshoz (nincs szükség max-height beállításra)
- Billentyűzet támogatás (Tab navigáció + Space/Enter váltás)
- Ikon váltás (plus ↔ minus) az állapot szerint
- Automatikus spacing egymást követő accordionok között
- Automatikus cleanup DOM elemek eltávolításakor
<x-pds.accordion title="Első elem">
Tartalom itt...
</x-pds.accordion>
<x-pds.accordion title="Második elem" :open="true">
Ez nyitva van alapból.
</x-pds.accordion>
<x-pds.accordion title="Letiltott elem" :disabled="true">
Ez nem nyitható meg.
</x-pds.accordion>
Accordion példák
Speciális esetek
:open="true" prop miatt.
Modalban (mobil tesztelhetőség miatt)
Avatar
Avatar alkalmazása
ds-avatar class
ds-avatar-premiumds-avatar-shadowds-avatar-borderds-avatar-[size]
ds-avatar class definiálja az alapvető stílust, emellé megadható:
ds-avatar-premium- prémium gradient borderds-avatar-shadow- árnyék hatásds-avatar-border- szimpla border (nem prémium esetén)ds-avatar-[size]- méret (xs, sm, md, lg, xl)
x-pds.avatar komponens
sizeimgpremiumshadowborderbadge
Paraméterek:
size- méret:xs,sm,md,lg,xlimg- egyedi kép URL (opcionális)premium- prémium gradient border (boolean)shadow- árnyék hatás (boolean)border- szimpla border (boolean)badge- státusz badge megjelenítése (boolean)
Ha nincs
img megadva, automatikusan betölti az alapértelmezett avatar képet (prémium vagy normál verzió).
Avatar típusok
JavaScript Dynamic Avatar Creation
Dinamikus avatar létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side rendering)
Elérhető API metódusok
window.pds.avatar.create(options)– Új avatar elem létrehozásawindow.pds.avatar.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.avatar.render(options)– HTML string generálása
1. Méretváltozatok Létrehozása
window.pds.avatar.create({ size }) – Avatár létrehozása méret szerint, normál és prémium verzióban
Kód megjelenítése
// Normál méretsor
['xs', 'sm', 'md', 'lg', 'xl'].forEach(size => {
const avatar = window.pds.avatar.create({ size });
container.appendChild(avatar);
});
// Prémium méretsor
['xs', 'sm', 'md', 'lg', 'xl'].forEach(size => {
const avatar = window.pds.avatar.create({ size, premium: true });
container.appendChild(avatar);
});
2. Badge Dot Dinamikus Toggle
Az badge állapot változtatható a komponens újra-létrehozásával.
Kód megjelenítése
// Kezdeti állapot – badge nélkül
let hasBadge = false;
const container = document.getElementById('avatar-example-4');
let avatarEl = window.pds.avatar.createAndMount(container, {
size: 'xl',
border: true,
badge: hasBadge
});
// Toggle gomb: komponens újra-renderelése
document.getElementById('toggle-btn').addEventListener('click', () => {
hasBadge = !hasBadge;
container.innerHTML = '';
avatarEl = window.pds.avatar.createAndMount(container, {
size: 'xl',
border: true,
badge: hasBadge
});
});
3. Csak HTML String Generálás
window.pds.avatar.render() – Csak HTML stringet ad vissza, nincs DOM manipuláció.
Hasznos server-side templating helyettesítésekor vagy innerHTML-be íráshoz.
Kód megjelenítése
// Csak HTML string – nincs DOM-ra hivatkozás
const html = window.pds.avatar.render({
size: 'lg',
premium: true,
shadow: true
});
container.innerHTML += html;
Badgek
Badge komponens használata
Alap beállítások
colorsizecontentcustomClass
A
color (alapértelmezett: primary) határozza meg a badge színét.A
size lehet xs, sm vagy md (alapértelmezett: md).A
content a badge szövege.A
customClass további CSS osztályok hozzáadására szolgál.
Ikonok
iconiconVarianticonSize
Az
icon a badge-hez tartozó ikon neve (pl. star, check-circle).Az
iconVariant lehet line vagy solid (alapértelmezett: line).Az
iconSize automatikusan meghatározódik a badge mérete alapján, de manuálisan is beállítható.
Azonosító
id
Az
id a badge egyedi azonosítója (opcionális, automatikusan generált uniqid).
Elérhetőség
focusable
A
focusable (boolean, alapértelmezett: false) meghatározza, hogy a badge fókuszálható-e.Ez különösen hasznos tooltipek használatához.
Semantic Icon
Semantic color esetén (
*-semantic) az ikon automatikusan meghatározódik, ha nincs megadva:-
success-semantic → check-circle-
info-semantic, warning-semantic, alert-semantic → info-circle-
neutral-semantic → nincs ikon
Blade használat
-
<x-pds.badge content="Új" color="primary" size="md" /> -
<x-pds.badge content="Success" color="success-semantic" /> -
<x-pds.badge content="Featured" icon="star" iconVariant="solid" /> -
<x-pds.badge color="info-semantic" :focusable="true" /> -
<x-pds.badge content="Beta" color="purple-highlighted" size="sm" />
JavaScript használat
A Badge komponens **nincs automatikusan hidratálva**, mert nincs JS interakciója.
Dinamikus létrehozáshoz használd a
window.pds.badge API-t:// Egyszerű létrehozás
const badge = window.pds.badge.create({ content: 'New', color: 'success-semantic' });
container.appendChild(badge);// Létrehozás és hozzáadás egy lépésben
window.pds.badge.createAndMount(container, { content: 'Featured', icon: 'star' });// Csak HTML generálás
const html = window.pds.badge.render({ content: 'HTML Only' });
Nincs hidratáció
A Badge-nek nincs JavaScript logikája, így nincs szükség ComponentRegistry hidratálásra.
Csak megjelenítési célt szolgál, event handling nincs.
Badge Semantic (focusable:true-val)
Badge Basic
Badge highlighted
Badge Advanced
Badge responsive
JavaScript Dynamic Badge Creation
Dinamikus badge létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side rendering)
1. Egyszerű Badge Létrehozás
window.pds.badge.create() - Létrehoz egy badge-et, ami készen áll a DOM-ba való beszúrásra
// 1. Egyszerű létrehozás
const badge = window.pds.badge.create({
content: 'New'
});
container.appendChild(badge);
2. Létrehozás és Hozzáadás Egy Lépésben
window.pds.badge.createAndMount(container, options) - Létrehoz és azonnal hozzáad egy konténerhez
// 2. Létrehozás és hozzáadás
window.pds.badge.createAndMount(container, {
content: 'Success',
color: 'success-semantic'
});
3. Badge Ikonnal
Badge létrehozása egyedi ikonnal és különböző méretekben
// 3. Badge ikonnal és mérettel
window.pds.badge.create({
content: 'Featured',
icon: 'star-01',
iconVariant: 'solid',
color: 'purple',
size: 'md'
});
4. Tömeges Létrehozás (AJAX Szimuláció)
Több badge létrehozása egyszerre (pl. szerver válaszból)
// 4. AJAX példa
fetch('/api/statuses')
.then(res => res.json())
.then(statuses => {
statuses.forEach(status => {
window.pds.badge.createAndMount(container, {
content: status.label,
color: status.color,
icon: status.icon
});
});
});
5. Csak HTML Generálás
window.pds.badge.render() - Csak HTML stringet ad vissza
Megjegyzés: A Badge-nek nincs hidratálása, mert nincs JS logikája!
// 5. Csak HTML (hidratálás NEM szükséges!)
const html = window.pds.badge.render({
content: 'HTML Only',
color: 'yellow'
});
container.innerHTML += html;
Badge Dot
Badge Dot class strukturúrája
ds-badge-dotds-badge-dot-[size]
ds-badge-dot-size-xs, ds-badge-dot-size-sm, ds-badge-dot-size-md, ds-badge-dot-size-lg, ds-badge-dot-size-xl méretek,
azonban az alapértelmezett méret a ds-badge-dot-size-12, azt nem kell definiálni.
ds-badge-dot-[color]
Badge dot
Borders
Border - color
Border - size
Megadható bármilyen oldalon egyedileg is.
Border - Radius
radius-top-lg radius-left-lg radius-bottom-lg radius-right-lg
radius-top-left-md radius-bottom-left-md radius-bottom-right-md radius-top-right-md
Vagy lehet variálni is, ...de ilyenkor már jobb egy custom class.
Premium borders
Border - color
Border - size
Megadható bármilyen oldalon egyedileg is.
Border - Radius
radius-top-lg radius-left-lg radius-bottom-lg radius-right-lg
radius-top-left-md radius-bottom-left-md radius-bottom-right-md radius-top-right-md
Vagy lehet variálni is, ...de ilyenkor már jobb egy custom class.
Button (figma)
Gombok class strukturúrája
ds-btnds-btn-[type]
ds-btn-textds-btn-icon- (
ds-btn-only-icon)
ds-btn-text, valamint a ds-btn-icon. Van még egy alverzió, a
ds-btn-only-icon, ami csak ikont tartalmaz, de ez egy egyedi verziója a ds-btn-nak, design-ban néhány helyen ezt alkalmazzák.
ds-btn-[sizing]
ds-btn-smds-btn-mdds-btn-lg+1: ds-btn-h100+1: ds-btn-h-unset+1: ds-btn-h-initial
ds-btn-sm, (ds-btn-md) és ds-btn-lg méretek,
azonban az alapértelmezett méret a md, azt nem kell definiálni (nem is lehet, nincs is külön ilyen osztály definiálva).
Ha szeretnénk, hogy egy gombunk 100%-os magasságú legyen, akkor a
ds-btn-h100, ds-btn-h-unset, ds-btn-h-initial class valamelyikét kell használnunk.
ds-btn-[hierarchy]
ds-btn-primaryds-btn-secondaryds-btn-tertiaryds-btn-accentds-btn-ghostds-btn-inverseds-btn-destructive
ds-btn-primary,
ds-btn-secondary,
ds-btn-tertiary,
ds-btn-accent,
ds-btn-ghost,
ds-btn-inverse és
ds-btn-destructive gombokat. A desctuctive stílusok speciálisak, ugyanis a klasszikus gomboknál eltérő fő hierarchia szerint, ezért azt is definiálni kell, hogy melyik fő hierarchiához tartozik (primary, secondary, tertiary, accent, ghost).
ds-btn-[addon]
ds-btn-addon-
ds-btn-leading-iconds-btn-trailing-icon
ds-btn-addon classt használjuk a gombon,
az ikonra pedig pozíciótól függően ds-btn-leading-icon vagy ds-btn-trailing-icon classal hivatkozunk.
ds-btn [data-progress]data-progress attribútumot.
A
data-progress="false" esetén nem fog töltődni, így akár beállíthatunk egy változót is az értékének.
Kódrészlet
<button class="ds-btn ds-btn-primary">
Primary button
</button>
Implementáció
ds-btn
ds-btn-text & ds-btn-icon
sm
primary text button
sm-primary: anchor tagsecondary text button
sm-secondary: anchor taginverse text button
sm-inverse: anchor tagdestructive text button
sm-destructive: anchor tagmd
primary text button
md-primary: anchor tagsecondary text button
md-secondary: anchor taginverse text button
md-inverse: anchor tagdestructive text button
md-destructive: anchor taglg
primary text button
lg-primary: anchor tagsecondary text button
lg-secondary: anchor taginverse text button
lg-inverse: anchor tagdestructive text button
lg-destructive: anchor tagsm
md
Button: Progress status
Button Progress Utility
window.pds.initProgressButton - definiálja egy gombhoz az utility-t.
Input paraméterek:
btn- a kiválasztott gomb HTMLElement-je(disableInProgress=true)- a folyamat alatt le legyen-e tiltva.
Visszatérési érték:
status- A progress állapotát adja vissza + watch funkció: ezzel követni lehet a progress aktuális állapotát.fetchWithProgress- Egy olyan fetch, ami automatikusan módosíthja a hozzákapcsolt gomb progress státuszát.
Progress Button with automatic status management
Button: Social
ds-btn-social-[type]
ds-btn-social-appleds-btn-social-googleds-btn-social-facebook
ds-btn-social-facebook,
ds-btn-social-apple,
ds-btn-social-google.
Az ikonokat nem kell hozzáadni, uganis azt tartalmazza a
before pseudo element.
További funkciók
ds-btn-only-iconds-btn-lg
ds-btn-only-icon classt is.
Ha nagyobb méretű gombot szeretnénk, akkor a
ds-btn-lg classt alkalmazzuk, akár a csak-ikonos verzióban is.
ds-btn-toggle
Button Toggle Utility
data-ds-toggledata-ds-toggle attribútummal, automatikusan hozzárendelődik a toggle funkcionalitás.
A gomb kattintáskor váltogatja az aria-pressed attribútum értékét "true" és "false" között.
data-ds-toggle="initialized"
aria-pressed érték megadva, automatikusan "false"-ra állítódik.
A rendszer automatikusan kezeli a memóriát MutationObserver segítségével.
window.pds.initToggleButtons()
initToggleButtons()initToggleButtons(container)
Megjegyzés: Alapértelmezetten nem kell meghívni, mert automatikusan működik.
window.pds.cleanupToggleButtons()
- Automatikus cleanup
- Manuális cleanup
element.remove(), container.innerHTML = '', jQuery $('#element').remove()
Manuális cleanup szükséges: SPA route váltás, modal bezárás, alkalmazás leállítás, régi böngészők esetén.
A legtöbb esetben nem kell foglalkozni vele, mert automatikusan működik.
Kódrészlet
<button class="ds-btn ds-btn-toggle" data-ds-toggle>
Toggle button
</button>
Implementáció
ds-btn-h* - ds-flex-row esetén
Colors
Text colors
Default colors
Gradients
Default colors
Backgrounds
Default colors
Color mix
Van olyan eset, amikor egy adott színnek egy árnyalatát szeretnék alkalmazni. Ennek a megvalósítását nem simán opacity-vel valósítják meg, és nem is simán before/after pseudo beállításával, hanem color-mix függvénnyel.
Emiatt viszont nem lehet előre classokat definiálni, hanem a css-ben kell beállítani hozzá a color-mix css funkcióval a pds által definiált változók alapján.
Ha az alapvető háttér színt szeretnék ezzel keverni, azaz az aktuális elemünk átlátszó, akkor az "alapszínt" átlátszóvá kell tenni.
Ezekre azért nincs egyedi class, mert nincsenek előre definiált színek, amikre állandóan ráteszik, ez változhat a komponens színeitől függően.
Premium colors
Text colors
Default colors
Gradients
Default colors
Backgrounds
Default colors
Color mix
Van olyan eset, amikor egy adott színnek egy árnyalatát szeretnék alkalmazni. Ennek a megvalósítását nem simán opacity-vel valósítják meg, és nem is simán before/after pseudo beállításával, hanem color-mix függvénnyel.
Emiatt viszont nem lehet előre classokat definiálni, hanem a css-ben kell beállítani hozzá a color-mix css funkcióval a pds által definiált változók alapján.
Ha az alapvető háttér színt szeretnék ezzel keverni, azaz az aktuális elemünk átlátszó, akkor az "alapszínt" átlátszóvá kell tenni.
Ezekre azért nincs egyedi class, mert nincsenek előre definiált színek, amikre állandóan ráteszik, ez változhat a komponens színeitől függően.
Select Input
Select Input alkalmazása
<x-pds.form-control.select-input> Komponens
name(string) - kötelezőid(string)label(string)placeholder(string)options(array) - kötelezőselected(string|array)multiple(bool, false)multipleType('list'|'tag')multipleWrap(bool, false)mobileNative(bool, true)cleanupTemplate(bool, true)clearable(bool, false)disabled(bool, false)required(bool, false)leadingIcon(string)dropdownWidth('auto')dropdownPosition('top')dropdownAlign('right' | 'left')optionSize(string)form(string)
A komponens a natív HTML select elem körül épül fel, ezért minden natív select tulajdonság támogatott.
Alap props:
name - A form mező neve (kötelező)id - Egyedi azonosító (ha nincs megadva, automatikusan generálódik)label - Címke szöveg a select fölöttplaceholder - Helyettesítő szöveg, amikor nincs kiválasztva semmioptions - Opciók tömbje (lásd lejjebb)selected - Előre kiválasztott érték(ek)Többszörös kiválasztás:
multiple - Többszörös kiválasztás engedélyezésemultipleType - Megjelenítés típusa: 'list' (felsorolás) vagy 'tag' (címkék)multipleWrap - Tördelés engedélyezése (alapból: false, vízszintes scrollozás)UI opciók:
mobileNative - Mobil eszközökön natív select használata (alapból: true)clearable - X gomb megjelenítése a kiválasztás törléséhezleadingIcon - Ikon megjelenítése a trigger elejéndropdownWidth - 'auto' esetén a dropdown szélessége alkalmazkodik a tartalomhozdropdownPosition - 'top' esetén a dropdown felfelé nyílikdropdownAlign - 'right' esetén a dropdown jobbra igazodik (ilyenkor a szélesség a tartalom alapján jelenik meg, különben nem volna jelentőssége). (Van 'left' is, de ekvivalens az 'auto-width'-el)optionSize - Opció mérete (sm/md/lg)Teljesítmény és optimalizáció:
cleanupTemplate - Template-ek memóriában tárolása és DOM-ból való eltávolítása (alapból: true)- Instance-level cache használata memória szivárgás megelőzésére
- Automatikus cleanup a komponens megszűnésekor
- Tisztább DOM, gyorsabb template klónozás
Form opciók:
disabled, required, form - Natív HTML attribútumok
További konfigurálási beállítások
data-* Attribútumok
Select elemen:
data-placeholderdata-multiple-typedata-dropdown-widthdata-dropdown-position
data-icondata-trailing-icondata-subtitledata-linkdata-[tetszőleges-role]
data-remove-[role-név]
A <select> elemen:
Ezek az attribútumok a teljes komponens viselkedését szabályozzák.
data-placeholder - Placeholder szövegdata-multiple-type - Többszörös kiválasztás típusa ('list' vagy 'tag')data-dropdown-width - 'auto' esetén tartalomhoz igazodó szélességdata-dropdown-position - Dropdown pozíciója ('top' = felfelé nyílik)A wrapper elemen:
data-cleanup-template - Template cache és DOM cleanup (alapból: true)Ha "false" értékű, a template-ek a DOM-ban maradnak
Az <option> elemen - Alapértelmezett role-ok:
data-icon - Vezető ikon neve (pl. 'check-circle')data-trailing-icon - Záró ikon nevedata-subtitle - Alcím szöveg az opció alattdata-role Rendszer
A három elem kapcsolata:
data-role="[role-név]"data-placeholder-role-[role-név]="[__MASK__]"- Template-ben:
"[__MASK__]"
Elérhető role-ok:
trigger-texticontrailing-icontextsubtitletaglink- + tetszőleges egyéni role
A data-role rendszer három elem szoros együttműködésén alapul, amely lehetővé teszi a dinamikus placeholder csere mechanizmust.
1. data-role="[role-név]" - Azonosítás
A template-ben lévő elemeket azonosítja, amelyeket fel kell tölteni az option adataival.
Például:
<span data-role="text"></span>
2. data-placeholder-role-[role-név]="[__MASK__]" - Placeholder definíció
Definiálja azt a placeholder string-et, amelyet le kell cserélni az option
data-[role-név] értékére.Például:
<div data-role="icon" data-placeholder-role-icon="__LEADING_ICON__">
3. Placeholder string ("[__MASK__]") előfordulásai - Csere
A placeholder string bárhol előfordulhat a template-ben, és minden előfordulás lecserélődik az option adatával.
Egyéni role-ok - Rugalmas bővíthetőség:
A rendszer tetszőleges
data-[role-név] attribútumot támogat!Példák:
data-link, data-badge, data-color, data-tooltipFontos: A data attribútum neve mindig megegyezik a template-ben használt
data-role értékkel.Hogyan jelenik meg a role értéke?
A
data-role="[role-név]" elem az option data-[role-név] attribútumának értékét jeleníti meg:1. Ha NINCS placeholder definiálva a <select> elemen:
Az érték az elem
innerText-jébe kerül.Példa:
<span data-role="subtitle"></span> → <span>Magyar</span>
2. Ha VAN
data-placeholder-role-[role-név] definiálva a <select> elemen:A
<select data-placeholder-role-link="__LINK__"> attribútumban megadott placeholder string minden előfordulása lecserélődik az option értékére:• A data-role elem attribútumaiban (href, class, style, stb.)
• A data-role elem szöveges tartalmában (innerText/textContent)
• A data-role elem gyermekeiben (az alatta lévő DOM fában)
Példa:
Select:
<select data-placeholder-role-link="__LINK__">Template:
<a data-role="link" href="__LINK__">Tovább: __LINK__</a>Option:
<option data-link="example.com">Eredmény:
<a href="example.com">Tovább: example.com</a>
Eltávolító attribútumok - DOM tisztítás:
data-remove-[role-név] - Ha egy option-ön szerepel, az adott role-ú elem teljesen eltávolításra kerül a DOM-ból.Cél: Megakadályozza, hogy felesleges/hibás DOM elemek maradjanak a renderelt opcióban.
Példa: Ha egy opció-nak nincs ikonja, a
data-remove-icon használatával az ikon konténer elem teljesen eltűnik a DOM-ból, nem csak elrejtésre kerül.
Child element-ekben (rekurzívan):
Példa:
<div data-role="icon" data-placeholder-role-icon="__ICON__">
<svg class="icon-__ICON__">
<use href="#__ICON__"></use>
</svg>
</div>
Option: <option data-icon="check-circle">Eredmény: MINDEN "__ICON__" → "check-circle" (class-ban ÉS href-ben is!)
Teljes példa link role-lal:
<a href="__LINK__"
target="_blank"
data-role="link"
data-placeholder-role-link="__LINK__">
Megnyitás: __LINK__
</a>
Option: <option data-link="https://example.com">Eredmény:
<a href="https://example.com"
target="_blank">
Megnyitás: https://example.com
</a>
Fontos megjegyzések:
- A placeholder csere rekurzív - minden gyermek elemben és azok attribútumaiban is végbemegy
- A
data-placeholder-role-*attribútumok a csere után automatikusan törlődnek - Ha nincs
data-placeholder-role-*attribútum, csak a textContent-et tölti ki - A
data-remove-*használatával a teljes role-ú elem eltávolítható
DsSelectInput JS inicializálás
Konstruktor:
selectElement- kötelezőoptions- opcionális
Options objektum:
triggerTemplateIddropdownTemplateIdoptionTemplateIdtagTemplateIdtagsContainerTemplateIdmobileNativemultipleTypecleanupTemplate
Ha Blade komponens helyett tisztán JavaScript-tel szeretnél létrehozni egy select input-ot, a következőkre kell figyelni:
1. HTML struktúra létrehozása:
<div data-ds-select-wrapper class="ds-select-input-wrapper">
<select name="my-select" id="my-select">
<option value="1" data-icon="check">Option 1</option>
<option value="2" data-icon="x">Option 2</option>
</select>
</div>
2. Template-ek definiálása:
Létre kell hozni az alábbi
<template> elemeket:• Trigger template - a kattintható select mező
• Dropdown template - a legördülő lista konténer
• Option template - egy opció megjelenítése a dropdown-ban
• Tag template (opcionális) - multiple + tag mód esetén
• Tags container template (opcionális) - tag-ek konténere
3. Placeholder szintaxis a template-ben:
Használj értelmes, egyedi placeholder string-eket (pl.
__LEADING_ICON__, __LINK__).A placeholder bármilyen formátumú lehet, javasolt konvenció az áttekinthetőség érdekében:
__UPPERCASE_WITH_UNDERSCORES__
4. DsSelectInput példányosítás:
const selectEl = document.querySelector('#my-select');
const instance = new window.pds.DsSelectInput(selectEl, {
triggerTemplateId: 'my-trigger-template',
dropdownTemplateId: 'my-dropdown-template',
optionTemplateId: 'my-option-template',
tagTemplateId: 'my-tag-template', // opcionális
tagsContainerTemplateId: 'my-tags-container', // opcionális
mobileNative: true, // alapból: true
multipleType: 'list', // 'list' vagy 'tag'
cleanupTemplate: true // alapból: true, memória optimalizáció
});
5. Teljes működő példa:
Lásd a "JS oldalról létrehozva" szekciót lejjebb, ahol egy komplett példa található a
createDynamicSelect() függvényben.
⚠️ Fontos tudnivalók:
- A wrapper-nek kötelező a
[data-ds-select-wrapper]attribútum - A select elem-nek kötelező a
nameésidattribútum - Ha nincs megadva template ID, automatikusan generálódik a select ID/name alapján
- A template-ekben használt
data-roleésdata-placeholder-role-*attribútumok elengedhetetlenek a működéshez - Az option elemeken a
data-*attribútumoknak meg kell egyezniük a template role neveivel - Az auto-inicializálás letiltható, ha nem a DOMContentLoaded-kor történik a betöltés
- Template Cache: A
cleanupTemplate: true(alapértelmezett) esetén a template-ek instance-level cache-be kerülnek és törlődnek a DOM-ból. Adestroy()híváskor automatikusan tisztítódik a memória. Kikapcsolása csak debug/fejlesztés céljából ajánlott.
Code Input
Code Input alkalmazása
x-pds.form-control.code-input
namelabelreadonlyerror-messages(warning-messages)(info-messages)(success-messages)
additional-infoadditional-is-inverseadditional-iconadditional-titleadditional-btnadditional-callback
DsCodeInput
constructor(element)_rootElement_setValue(value)_dsInstancedestroy()
element paraméter a wrapper DOM elem ([data-ds-code-input] attribútummal). A komponens automatikusan inicializálódik a ComponentRegistry által, nem szükséges manuálisan példányosítani._rootElement: Getter, amely visszaadja a komponens gyökér DOM elemét.
_setValue(value): Programozottan beállítja a kód értékét. A
value paraméter egy string, amelyet szétosztva kitölti az input mezőket._dsInstance: A root elemen tárolt referencia az inicializált
DsCodeInput osztály példányára. A ComponentRegistry automatikusan létrehozza és eltárolja ezt a referenciát. A _dsInstance lehetővé teszi, hogy később elérjük a komponens metódusait (pl. element._dsInstance._setValue('1234')).destroy(): Felszabadítja az event listenereket és tisztítja a referenciákat. Automatikusan meghívódik a komponens DOM-ból való eltávolításakor.
input-complete - Akkor aktiválódik, amikor mind a 4 mező ki van töltve. Az event.detail tartalmazza a name és value tulajdonságokat.init-complete - Akkor aktiválódik, amikor a komponens inicializálása befejeződött.
Funkciók:
• Csak alfanumerikus karaktereket (0-9, a-z, A-Z) fogad el
• Automatikus fókuszváltás a következő mezőre
• Paste támogatás - a teljes kódot egyben be lehet illeszteni
• Backspace-szel visszalépés az előző mezőre
• Focus esetén az aktuális karakter kijelölése
Megjegyzés: A komponens tartalmaz egy rejtett input mezőt (
name attribútummal), amely tartalmazza az összes beírt karakter összefűzött értékét, így form submit esetén ez az érték kerül elküldésre.
Code Input példa
Form Controls
Input - Basic
Input - Leading
Input - Trailing icon
Trailing button alkalmazása
trailing-button
trailing-button="button-name"trailing-button-colortrailing-button-variant
A button neve (
trailing-button="button-name") kötelező paraméter. A trailing-button-color="var(--color)" segítségével állítható a button színe,
a trailing-button-variant pedig a button variánsát határozza meg (line vagy solid).
trailing-button-function
JavaScript függvények definiálására szolgál. A
trailing-button-function="alert('Hello!')" segítségével állítható be a click eseményre futó függvény. A gomb mindig click eseményre reagál.
Speciális példák
PHP változók beágyazása a JavaScript függvényekbe.
trailing-button-function="performAction()"trailing-button-function="MyApp.search()"
Input - Trailing Button
Input - Password alkalmazása
Minden ugyanaz, mint az input-nál csak input helyett input-password a component neve.
Ezen kívül van lehetőség a jelszóerősség megjelenítésére a
showPasswordStrength=true paraméterrel. Ekkor a default PasswordStrengthCalculator fut le, viszont van lehetőség saját függvény átadására is a passwordStrengthCustomScorer="customPasswordStrengthScorer" -el pl. Erre példa lentebb található.A saját validáció megírása a jelszóerősség kiírására a fejlesztő felelőssége. -1, 0, 1, 2, 3, 4 level-t adhat vissza, ahol a -1 az, hogy nem adta meg, a többi pedig a jelszó erősségére vonatkozó értékek, 4 a legerősebb.
Password Input – JavaScript Dinamikus Létrehozás
Dinamikus jelszó input létrehozás JavaScript-ből – beleértve a jelszóerősség-mérő injektálását is.
Elérhető API metódusok
window.pds.passwordInput.create(options)– Új jelszó input létrehozása, DsPasswordInput instance visszatérési értékkelwindow.pds.passwordInput.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.passwordInput.render(options)– Csak HTML string generálása
A create() egy DsPasswordInput instance-t ad vissza (kiterjeszti DsInput-t).
A wrapper._dsInstance property ugyanolyan módon elérhető, mint Blade-ből renderelt jelszó inputnál.
Ha showPasswordStrength: true, a factory automatikusan injektálja az erősség-konténert
a beforeMessages slotba, még a hydration előtt.
1. Password Input Variánsok
Alap, clearable, required és disabled jelszó mezők dinamikus létrehozása. A jelszó megjelenítés/elrejtés gomb (eye toggle) automatikusan aktív.
Kód megjelenítése
// Alap jelszó mező
window.pds.passwordInput.createAndMount(container, {
name: 'pw_alap',
label: 'Alap jelszó',
placeholder: 'Írd be a jelszavad...',
});
// Clearable jelszó
window.pds.passwordInput.createAndMount(container, {
name: 'pw_clearable',
label: 'Clearable jelszó',
value: 'titkos123',
clearable: true,
});
// Kötelező mező
window.pds.passwordInput.createAndMount(container, {
name: 'pw_required',
label: 'Kötelező jelszó',
required: true,
clearable: true,
});
// Disabled
window.pds.passwordInput.createAndMount(container, {
name: 'pw_disabled',
label: 'Nem szerkeszthető jelszó',
value: 'disabled_pass',
disabled: true,
});
2. Jelszóerősség-mérő + _dsInstance Elérés
Ha showPasswordStrength: true, a factory automatikusan létrehozza
és a beforeMessages slotba injektálja az erősség-konténert (a Blade
<x-slot name="beforeMessages"> JS megfelelője).
A DsPasswordStrengthCalculator a hydration során rögtön inicializálódik.
–
Kód megjelenítése
const instance = window.pds.passwordInput.create({
name: 'new_password',
label: 'Új jelszó',
id: 'new_password_1',
showPasswordStrength: true,
clearable: true,
errorMessages: ['A jelszó túl rövid.'],
});
document.getElementById('pw-example-2').appendChild(instance.wrapper);
// _dsInstance ugyanúgy elérhető, mint Blade-rendered inputnál
console.log(instance.wrapper._dsInstance === instance); // true
console.log(instance.wrapper._dsInstance instanceof window.pds.DsPasswordInput); // true
3. Csak HTML String Generálás
window.pds.passwordInput.render() – Csak HTML stringet ad vissza,
nincs DOM-manipuláció és nincs DsPasswordInput hydration.
Hasznos szerver-oldali templating helyettesítésekor vagy innerHTML-be íráshoz.
Az így beszúrt input nem rendelkezik eye-toggle és clearable JS viselkedéssel.
Kód megjelenítése
// Csak HTML string – nincs DOM-ra hivatkozás, nincs hydration
const html = window.pds.passwordInput.render({
name: 'html_pw_only',
label: 'HTML-only jelszó input',
placeholder: 'Statikus HTML...',
additionalInfo: 'Ez az input csak HTML, nincs JS viselkedés (eye toggle sem).',
});
container.innerHTML += html;
Input - Tooltip info help
Input - Addon info help
Input - Inverse addon info help
Input – JavaScript Dinamikus Létrehozás
Dinamikus input létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side form építéshez)
Elérhető API metódusok
window.pds.input.create(options)– Új input elem létrehozása, DsInput instance visszatérési értékkelwindow.pds.input.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.input.getSlot(wrapper, 'beforeMessagesSlot')– A$beforeMessagesslot konténer elérésewindow.pds.input.setSlot(wrapper, 'beforeMessagesSlot', content)– Tartalom elhelyezése a$beforeMessagesslot-banwindow.pds.input.render(options)– Csak HTML string generálása
A create() egy DsInput instance-t ad vissza.
A wrapper._dsInstance property ugyanolyan módon elérhető, mint Blade-ből renderelt inputnál.
1. Input Variánsok Létrehozása
window.pds.input.createAndMount(container, options) –
Különböző konfigurációjú input elemek létrehozása egy lépésben.
Kód megjelenítése
// Alap input
window.pds.input.createAndMount(container, {
name: 'demo_alap',
label: 'Alap input',
placeholder: 'Írj be valamit...',
});
// Clearable input
window.pds.input.createAndMount(container, {
name: 'demo_clearable',
label: 'Clearable',
value: 'Törölhető tartalom',
clearable: true,
});
// Leading ikon
window.pds.input.createAndMount(container, {
name: 'demo_leading',
label: 'Leading ikon',
placeholder: 'E-mail cím',
leadingIcon: 'mail-01',
type: 'email',
});
// Trailing gomb
window.pds.input.createAndMount(container, {
name: 'demo_trailing_btn',
label: 'Trailing gomb (keresés)',
placeholder: 'Keresési kifejezés...',
trailingButton: 'search-md',
trailingButtonFunction: 'handleInputSearch',
});
2. Dinamikus Üzenetek Kezelése
Üzenet típusok (error, warning, info, success) dinamikusan adhatók hozzá az input létrehozásakor. Az input újra-renderelésével az üzenetek frissíthetők.
Kód megjelenítése
// Input újra-renderelése üzenetekkel
function renderInputWithMessages(type) {
const container = document.getElementById('input-example-2');
container.innerHTML = '';
const messageMap = {
error: { errorMessages: ['Ez a mező kötelező.', 'Érvénytelen formátum.'] },
warning: { warningMessages: ['Lejárt adat – ellenőrizd az értéket.'] },
info: { infoMessages: ['Legalább 8 karakter szükséges.'] },
success: { successMessages: ['Az érték megfelelő formátumú.'] },
};
const instance = window.pds.input.createAndMount(container, {
name: 'demo_messages',
label: 'Validált mező',
value: 'teszt@domain.hu',
type: 'email',
...( messageMap[type] || {} ),
});
// _dsInstance ugyanúgy elérhető, mint Blade-rendered inputnál
console.log(instance.wrapper._dsInstance === instance); // true
}
3. beforeMessages Slot
A getSlot(wrapper, 'beforeMessagesSlot') / setSlot(wrapper, 'beforeMessagesSlot', content)
API a Blade $beforeMessages slot JS megfelelője.
Tetszőleges DOM tartalmat helyezhetünk az üzenetek fölé, post-creation is.
Kód megjelenítése
// 1. Input létrehozása error üzenetekkel
const instance = window.pds.input.createAndMount(container, {
name: 'promo_code',
label: 'Promóciós kód',
placeholder: 'PROMO-XXXX',
errorMessages: ['Érvénytelen kód.'],
});
// 2. Slot tartalom hozzáadása post-creation
const hint = document.createElement('div');
hint.className = 'ds-body-3 ds-color-secondary';
hint.textContent = 'Hint: a kód az e-mailben érkezett.';
window.pds.input.setSlot(instance.wrapper, 'beforeMessagesSlot', hint);
// Ugyanaz elérhető direktben a konténeren keresztül is:
const slotContainer = window.pds.input.getSlot(instance.wrapper, 'beforeMessagesSlot');
slotContainer.appendChild(document.createTextNode(' (pl. PROMO-2025)'));
4. Csak HTML String Generálás
window.pds.input.render() – Csak HTML stringet ad vissza, nincs DOM-manipuláció és nincs DsInput hydration.
Hasznos szerver-oldali templating helyettesítésekor vagy innerHTML-be íráshoz.
Az így beszúrt input nem rendelkezik clearable/trailingButton JS viselkedéssel.
Kód megjelenítése
// Csak HTML string – nincs DOM-ra hivatkozás, nincs hydration
const html = window.pds.input.render({
name: 'html_only',
label: 'HTML-only input',
placeholder: 'Csak statikus HTML...',
leadingIcon: 'user-01',
additionalInfo: 'Ez az input csak HTML, nincs JS viselkedés.',
});
container.innerHTML += html;
Textarea
Laravel komponensek
Kódrészlet
<x-pds.form-control.textarea label="Textarea" name="textarea-component" placeholder="Textarea" required/>
Implementáció
Textarea – JavaScript Dinamikus Létrehozás
Dinamikus textarea létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side form építéshez)
Elérhető API metódusok
window.pds.textarea.create(options)– Új textarea elem létrehozása, wrapperHTMLElementvisszatérési értékkelwindow.pds.textarea.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.textarea.getSlot(wrapper)– A$slotkonténer elérésewindow.pds.textarea.setSlot(wrapper, content)– Tartalom elhelyezése a slot-banwindow.pds.textarea.render(options)– Csak HTML string generálása
A create() a .ds-form-group wrapper HTMLElement-et adja vissza.
Ha maxLength van megadva, a <textarea> automatikusan kap DsTextarea
instance-t: wrapper.querySelector('textarea')._dsInstance.
1. Textarea Variánsok Létrehozása
window.pds.textarea.createAndMount(container, options) –
Különböző konfigurációjú textarea elemek dinamikus hozzáadása.
Kód megjelenítése
// Alap textarea
window.pds.textarea.createAndMount(container, {
name: 'demo_alap',
label: 'Alap textarea',
placeholder: 'Írd ide a szöveget...',
});
// Nem átméretezhető
window.pds.textarea.createAndMount(container, {
name: 'demo_fixed',
label: 'Rögzített méret',
placeholder: 'Nem lehet átméretezni...',
resizable: false,
rows: 3,
});
// Disabled és readonly
window.pds.textarea.createAndMount(container, {
name: 'demo_disabled',
label: 'Disabled',
value: 'Nem szerkeszthető tartalom',
disabled: true,
});
window.pds.textarea.createAndMount(container, {
name: 'demo_readonly',
label: 'Readonly',
value: 'Csak olvasható tartalom',
readonly: true,
});
2. Karakterszámláló és _dsInstance elérés
Ha maxLength van megadva, a DsTextarea class automatikusan hydratálódik.
A karakterszámláló aktív lesz, és a _dsInstance elérhető a <textarea> elemen.
_dsInstance elérhető: –
Kód megjelenítése
const wrapper = window.pds.textarea.createAndMount(container, {
name: 'demo_counter',
label: 'Üzenet (max 150 karakter)',
placeholder: 'Írd ide az üzeneted...',
maxLength: 150,
value: 'Kezdeti tartalom.',
});
// DsTextarea instance elérése a textarea elemen keresztül
const textareaEl = wrapper.querySelector('textarea');
const instance = textareaEl._dsInstance; // DsTextarea
console.log(instance instanceof DsTextarea); // true
// Az instance kezeli a karakterszámlálót automatikusan
3. Slot API: getSlot(wrapper) / setSlot(wrapper, content)
A getSlot(wrapper) / setSlot(wrapper, content)
metódusok a Blade {{ $slot }} JS megfelelői.
A textarea .ds-relative konténerén belül, a <textarea> után helyez el tartalmat.
Kód megjelenítése
// 1. Textarea létrehozása
const wrapper = window.pds.textarea.createAndMount(container, {
name: 'feedback',
label: 'Visszajelzés',
placeholder: 'Írd le a véleményed...',
error: ['A mező kitöltése kötelező.'],
});
// 2. Slot tartalom hozzáadása post-creation (pl. badge)
const badge = window.pds.badge.create({ content: 'AI-segített', color: 'info' });
window.pds.textarea.setSlot(wrapper, badge);
// Direktben a konténer is elérhető:
const slot = window.pds.textarea.getSlot(wrapper);
slot.appendChild(document.createTextNode(' – automatikus kiegészítés aktív'));
4. Csak HTML String Generálás
window.pds.textarea.render() – Csak HTML stringet ad vissza,
nincs DOM-manipuláció és nincs DsTextarea hydration.
Az így beszúrt textarea nem rendelkezik karakterszámláló JS viselkedéssel.
Kód megjelenítése
// Csak HTML string – nincs DOM-ra hivatkozás, nincs hydration
const html = window.pds.textarea.render({
name: 'html_only',
label: 'HTML-only textarea',
placeholder: 'Csak statikus HTML...',
additionalInfo: 'Ez a textarea csak HTML, nincs JS viselkedés.',
additionalIcon: 'info-circle',
});
container.innerHTML += html;
Checkbox komponens dokumentáció
ds-checkbox class
ds-checkbox-[size]ds-invalid
ds-checkbox class definiálja a jelölőnégyzet
stílusát. Megadható ds-checkbox-[size] a méretezéshez,
ds-invalid a hibás állapothoz.
x-pds.form-control.checkbox komponens
namelabelvaluecheckeddisabledrequirederrorsizetypeclass
Méretek:
sm,
(default),
lg
Állapotok:
checked,
disabled,
invalid,
required,
indeterminate
Tulajdonságok:
name (kötelező): A checkbox neve
label: A jelölőnégyzet címkéje
value: Az elem értéke
checked: Kiválasztott állapot
disabled: Letiltott állapot
required: Kötelező kitöltés
error: Hibaüzenetek tömbje
size: Méret (sm, default, lg)
type: Típus (indeterminate - bizonytalan állapot)
class: További CSS osztályok
Checkbox - Default, label nélkül
Checkbox - 3 méret: sm,(default),lg
Checkbox - Hibaüzenet, Kötelező
Checkbox - További állapotok
Checkbox – JavaScript Dinamikus Létrehozás
Dinamikus checkbox létrehozás JavaScript-ből. Pure visual komponens — nincs JS control class,
create() közvetlenül HTMLElement-et ad vissza.
Elérhető API metódusok
window.pds.checkbox.create(options)– Új checkbox elem létrehozása, HTMLElement visszatérési értékkelwindow.pds.checkbox.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.checkbox.render(options)– Csak HTML string generálása
A create() egy HTMLElement-et ad vissza (nincs hydration, mint a badge/avatar esetén).
A checkbox állapota közvetlenül az input elem tulajdonságaival olvasható (element.querySelector('input').checked).
1. Checkbox Variánsok
Alap, checked, disabled, required és indeterminate típusú checkbox-ok dinamikus létrehozása.
Kód megjelenítése
// Alap checkbox
window.pds.checkbox.createAndMount(container, {
name: 'cb_alap',
label: 'Alap checkbox',
});
// Checked állapot
window.pds.checkbox.createAndMount(container, {
name: 'cb_checked',
label: 'Kijelölve',
checked: true,
});
// Disabled
window.pds.checkbox.createAndMount(container, {
name: 'cb_disabled',
label: 'Letiltva',
disabled: true,
});
// Checked + Disabled
window.pds.checkbox.createAndMount(container, {
name: 'cb_checked_disabled',
label: 'Kijelölve + letiltva',
checked: true,
disabled: true,
});
// Indeterminate típus
window.pds.checkbox.createAndMount(container, {
name: 'cb_interminate',
label: 'Határozatlan állapot',
type: 'interminate',
checked: true,
});
2. Méretek és Hibaállapot
Három méretben (sm, default, lg) és hibaüzenettel.
A size opció a ds-checkbox-{size} CSS class-t adja hozzá.
Kód megjelenítése
// Kis méret
window.pds.checkbox.createAndMount(container, {
name: 'cb_sm',
label: 'Kis méret (sm)',
size: 'sm',
});
// Default méret (size elhagyható)
window.pds.checkbox.createAndMount(container, {
name: 'cb_default',
label: 'Alap méret (default)',
});
// Nagy méret
window.pds.checkbox.createAndMount(container, {
name: 'cb_lg',
label: 'Nagy méret (lg)',
size: 'lg',
});
// Hibaállapot
window.pds.checkbox.createAndMount(container, {
name: 'cb_error',
label: 'Elfogadom a feltételeket – kötelező',
error: ['Ez a mező kötelező.'],
});
3. Dinamikus Checkbox Lista
Checkbox elemek dinamikus generálása tömbből. Hasznos pl. szűrő opciók, érdeklődési körök
megjelenítésekor. Az állapot közvetlenül az input elemről olvasható.
Kód megjelenítése
// Adatok tömbje
const options = [
{ value: 'tech', label: 'Technológia', checked: true },
{ value: 'design', label: 'Design' },
{ value: 'marketing', label: 'Marketing', checked: true },
{ value: 'finance', label: 'Pénzügy' },
];
// Checkbox-ok generálása
options.forEach(opt => {
window.pds.checkbox.createAndMount(container, {
name: `interest_${opt.value}`,
id: `interest_${opt.value}`,
label: opt.label,
checked: opt.checked || false,
});
});
// Kijelölt értékek olvasása
const selected = Array.from(container.querySelectorAll('input[type="checkbox"]:checked'))
.map(input => input.name.replace('interest_', ''));
console.log(selected); // ['tech', 'marketing']
4. Csak HTML String Generálás
window.pds.checkbox.render() – Csak HTML stringet ad vissza,
nincs DOM-manipuláció. Hasznos innerHTML-be íráshoz.
Kód megjelenítése
// Csak HTML string – nincs DOM-ra hivatkozás
const html = window.pds.checkbox.render({
name: 'html_checkbox',
label: 'Statikus HTML checkbox',
size: 'lg',
checked: true,
});
container.innerHTML += html;
Switch komponens dokumentáció
ds-switch class
ds-switch-[size]ds-invalid
ds-switch class definiálja a kapcsoló
stílusát. Megadható ds-switch-[size] a méretezéshez
és ds-invalid a hibás állapothoz.
x-pds.form-control.switch komponens
namelabelcheckeddisabledrequirederrorsizeclass
Méretek:
sm,
md (default)
Állapotok:
checked,
disabled,
invalid,
required
Tulajdonságok:
name (kötelező): A switch neve
label: A kapcsoló címkéje
checked: Kiválasztott állapot
disabled: Letiltott állapot
required: Kötelező kitöltés
error: Hibaüzenetek tömbje
size: Méret (sm, md)
class: További CSS osztályok
Switch - Default, label nélkül
Switch - 2 méret: sm, md (default)
Switch - Labelekkel
Switch - Hibaüzenet, Kötelező
Switch - Használati példa szöveggel
Switch – JavaScript Dinamikus Létrehozás
Dinamikus switch (kapcsoló) létrehozás JavaScript-ből. Pure visual komponens — nincs JS control class,
create() közvetlenül HTMLElement-et ad vissza.
Elérhető API metódusok
window.pds.switch.create(options)– Új switch elem létrehozása, HTMLElement visszatérési értékkelwindow.pds.switch.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.switch.render(options)– Csak HTML string generálása
A create() egy HTMLElement-et ad vissza (nincs hydration, mint a checkbox/badge esetén).
A kapcsoló állapota közvetlenül az input elemről olvasható (element.querySelector('input').checked).
Az inputAttributes opció a Blade $attributes->except([...]) megfelelője.
1. Switch Variánsok
Alap, checked, disabled állapotok és méretek dinamikus létrehozása.
Kód megjelenítése
// Alap switch (md méret, label nélkül)
window.pds.switch.createAndMount(container, {
name: 'sw_alap',
});
// Checked állapot
window.pds.switch.createAndMount(container, {
name: 'sw_checked',
checked: true,
});
// Disabled
window.pds.switch.createAndMount(container, {
name: 'sw_disabled',
label: 'Letiltva',
disabled: true,
});
// Kis méret
window.pds.switch.createAndMount(container, {
name: 'sw_sm',
label: 'Kis méret (sm)',
size: 'sm',
checked: true,
});
2. Labelekkel és Hibaállapottal
Switch-ek magyarázó szöveggel és hibaüzenettel. A error tömb
a ds-switch-alert class-szal jelenik meg az elem alatt.
Kód megjelenítése
// Normál switch szöveggel
window.pds.switch.createAndMount(container, {
name: 'sw_notifications',
label: 'Email értesítések küldése',
checked: true,
});
// Disabled switch szöveggel
window.pds.switch.createAndMount(container, {
name: 'sw_push',
label: 'Push értesítések (letiltva)',
disabled: true,
});
// Hibaüzenettel
window.pds.switch.createAndMount(container, {
name: 'sw_required',
label: 'Elfogadom az értesítéseket – kötelező',
error: ['A kapcsoló bekapcsolása kötelező.'],
});
3. Dinamikus Beállítások Lista
Switch-ek generálása konfigurációs tömbből — pl. felhasználói beállítások megjelenítésekor.
Az állapot közvetlenül az input elemről olvasható és módosítható.
Kód megjelenítése
const settings = [
{ key: 'email', label: 'Email értesítések', checked: true },
{ key: 'push', label: 'Push értesítések', checked: false },
{ key: 'sms', label: 'SMS értesítések', checked: true },
{ key: 'weekly', label: 'Heti összefoglaló', checked: false },
];
// Beágyazott layout (sor: szöveg bal, switch jobb)
settings.forEach(setting => {
const row = document.createElement('div');
row.className = 'ds-flex-row ds-flex-justify-between ds-flex-align-center';
const textEl = document.createElement('span');
textEl.className = 'ds-body-2';
textEl.textContent = setting.label;
const sw = window.pds.switch.create({
name: `setting_${setting.key}`,
id: `setting_${setting.key}`,
checked: setting.checked,
size: 'sm',
});
row.appendChild(textEl);
row.appendChild(sw);
container.appendChild(row);
});
// Állapotok olvasása
const active = Array.from(
container.querySelectorAll('input[type="checkbox"]:checked')
).map(input => input.name.replace('setting_', ''));
console.log(active); // ['email', 'sms']
4. Csak HTML String Generálás
window.pds.switch.render() – Csak HTML stringet ad vissza,
nincs DOM-manipuláció. Hasznos innerHTML-be íráshoz.
Kód megjelenítése
const html = window.pds.switch.render({
name: 'html_switch',
label: 'Statikus HTML switch',
size: 'md',
checked: true,
});
container.innerHTML += html;
Radio Group komponens dokumentáció
ds-radio-group class
ds-invalid
ds-radio-group class definiálja a radio csoport
stílusát. Ha hiba van, akkor ds-invalid osztályt kapja,
amely az összes nem kiválasztott radio elemet hibás állapotba helyezi.
x-pds.form-control.radio-group komponens
nameoptionserrordisabledrequiredreadonlysizeclass
Méretek:
sm,
(md - default),
lg
Tulajdonságok:
• name (kötelező): A radio csoport neve
• options (kötelező): Tömb a radio opciókkal [label, value, checked, disabled, required, id]
• error: Hibaüzenetek tömbje
• disabled: Az egész csoport letiltása
• required: Az egész csoport kötelezővé tétele
• readonly: Az egész csoport readonlyvé tétele
• size: Méret (sm, default, lg)
• class: További CSS osztályok
• cardOptions: Nem kötelező, kártyahasználat. cardLayout az egyetlen option most, az értéke row vagy column lehet
Radio dokumentáció
ds-radio class
ds-radio-[size]ds-invalid
ds-radio class, ami definiálja a
stílust, emellé megadható ds-radio-[size] a méretezéshez
és ds-invalid a hibás állapothoz.
nameidvaluelabelsizecheckeddisabledrequirederrorclass
Állapotok:
checked,
disabled,
invalid,
required
Tulajdonságok: name (kötelező), value (kötelező), label, id, size, checked, disabled, required, readonly, class
Radio Group - Csoportok
Radio Group - Csoportos kezelés
Alapértelmezett radio csoport:
Radio csoport hibaüzenettel (minden invalid):
Letiltott radio csoport:
Különböző méretek:
Kis méret (sm):
Alapértelmezett:
Nagy méret (lg):
Kártyahasználat
Kis méret (sm) - oszlopba rendezés:
Alapértelmezett - oszlopba rendezés:
Nagy méret (lg) - sorba rendezés:
Alapértelmezett - alert - column:
Alapértelmezett - alert - row:
JavaScript Dynamic Radio Group Creation
Dinamikus radio group létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side rendering)
1. Egyszerű Radio Group létrehozás
window.pds.radioGroup.create() - Létrehoz egy radio group-et, ami készen áll a DOM-ba való beszúrásra
// 1. Egyszerű létrehozás
const radioGroup = window.pds.radioGroup.create({
name: 'gender',
options: [
{ label: 'Férfi', value: 'male' },
{ label: 'Nő', value: 'female', checked: true },
{ label: 'Egyéb', value: 'other' }
]
});
container.appendChild(radioGroup);
// Change esemény figyelése
radioGroup.addEventListener('change', (event) => {
const selectedValue = event.target.value;
const selectedLabel = event.target.nextElementSibling.textContent;
console.log('Kiválasztott:', selectedValue, selectedLabel);
});
2. Létrehozás és hozzáadás egy lépésben
window.pds.radioGroup.createAndMount(container, options) - Létrehoz és azonnal hozzáad egy konténerhez
// 2. Létrehozás és hozzáadás különböző méretekkel
window.pds.radioGroup.createAndMount(container, {
name: 'experience',
options: [
{ label: 'Junior', value: 'junior' },
{ label: 'Medior', value: 'medior' },
{ label: 'Senior', value: 'senior', checked: true }
],
size: 'lg'
});
3. Radio Group Hibaüzenettel
Radio group létrehozása hibaüzenettel és validációs állapottal
// 3. Hibaüzenettel
window.pds.radioGroup.createAndMount(container, {
name: 'required-field',
options: [
{ label: 'Opció 1', value: 'option1' },
{ label: 'Opció 2', value: 'option2' }
],
error: ['Kérjük válasszon egyet a lehetőségek közül.'],
required: true
});
4. Kártya elrendezés – Kis méret (sm) – Oszlop
Radio group kártya elrendezéssel, kis méret, oszlopba rendezve
window.pds.radioGroup.createAndMount(container, {
name: 'size-sm-group-with-card',
options: [
{ label: 'Kis méret opció 1', value: 'sm1' },
{ label: 'Kis méret opció 2', value: 'sm2' }
],
size: 'sm',
cardOptions: { cardLayout: 'column' }
});
5. Kártya elrendezés – Alapértelmezett – Oszlop
Radio group kártya elrendezéssel, alapértelmezett méret, oszlopba rendezve
window.pds.radioGroup.createAndMount(container, {
name: 'size-default-group-with-card',
options: [
{ label: 'Alapértelmezett opció 1', value: 'default1' },
{ label: 'Alapértelmezett opció 2', value: 'default2' }
],
cardOptions: { cardLayout: 'column' }
});
6. Kártya elrendezés – Nagy méret (lg) – Sor
Radio group kártya elrendezéssel, nagy méret, sorba rendezve
window.pds.radioGroup.createAndMount(container, {
name: 'size-lg-group-with-card',
options: [
{ label: 'Nagy méret opció 1', value: 'lg1' },
{ label: 'Nagy méret opció 2', value: 'lg2' }
],
size: 'lg',
cardOptions: { cardLayout: 'row' }
});
7. Kártya elrendezés hibaüzenettel – Oszlop
Radio group kártya elrendezéssel, alapértelmezett méret, oszlopba rendezve, hibaüzenettel
window.pds.radioGroup.createAndMount(container, {
name: 'size-default-group-with-card-error',
options: [
{ label: 'Alapértelmezett opció 1', value: 'default1' },
{ label: 'Alapértelmezett opció 2', value: 'default2' }
],
cardOptions: { cardLayout: 'column' },
error: ['Kérjük válasszon egyet a lehetőségek közül.']
});
8. Kártya elrendezés hibaüzenettel – Sor
Radio group kártya elrendezéssel, alapértelmezett méret, sorba rendezve, hibaüzenettel
window.pds.radioGroup.createAndMount(container, {
name: 'size-default-group-with-card-error-2',
options: [
{ label: 'Alapértelmezett opció 1', value: 'default1' },
{ label: 'Alapértelmezett opció 2', value: 'default2' }
],
cardOptions: { cardLayout: 'row' },
error: ['Kérjük válasszon egyet a lehetőségek közül.']
});
Icon featured
Icon featured alkalmazása
ds-icon-featured class
ds-icon-featured-[type]ds-icon-featured-[size]
ds-icon-featured class, ami definiálja a
stílust, emellé megadjató ds-icon-featured-[size] és ds-icon-featured-[type]
x-pds.icon-featured komponens
typesizeicon
Méretek:
,
sm,
md,
lg,
xl,
Típusok:
,
info,
warning,
alert,
success,
neutral,
secondary,
secondary-weak,
primary,
primary-weak,
tertiary,
tertiary-weak,
accent,
accent-weak,
gradient-brand,
gradient-brand-weak,
gradient-purple,
gradient-purple-weak,
gradient-premium,
gradient-premium-weak,
Ikon: az
untitled ui icon készletet lehet alkalmazni.
Icon featured típusok
Elérhető API metódusok
window.pds.iconFeatured.create(options)– Új icon-featured elem létrehozása, HTMLElement visszatérési értékkelwindow.pds.iconFeatured.createAndMount(container, options)– Létrehozás és DOM-ba helyezéswindow.pds.iconFeatured.render(options)– Csak HTML string generálása
Pure visual komponens — nincs JS control class, create() közvetlenül HTMLElement-et ad vissza.
1. Típusok és Méretek
Az összes típus és méret dinamikus generálása — az oldal betöltésekor megjelenik.
Kód megjelenítése
const types = ['neutral', 'info', 'warning', 'alert', 'success', 'primary', 'accent', 'gradient-premium'];
const sizes = ['', 'sm', 'md', 'lg', 'xl'];
types.forEach(type => {
const row = document.createElement('div');
row.className = 'ds-flex-column ds-gap-sm ds-flex-wrap';
const label = document.createElement('span');
label.textContent = type || 'undefined';
row.appendChild(label);
const icons = document.createElement('div');
icons.className = 'ds-flex-row ds-gap-sm';
sizes.forEach(size => {
icons.appendChild(window.pds.iconFeatured.create({ type, icon: 'info-circle', size }));
});
row.appendChild(icons);
container.appendChild(row);
});
2. Egyedi Ikon és Variáns
Különböző ikonok és solid variáns alkalmazása.
Kód megjelenítése
// line variáns (alapértelmezett)
window.pds.iconFeatured.createAndMount(container, {
type: 'success',
icon: 'check-circle',
size: 'xl',
});
// solid variáns
window.pds.iconFeatured.createAndMount(container, {
type: 'primary',
icon: 'star-01',
size: 'lg',
variant: 'solid',
});
// gradient típus
window.pds.iconFeatured.createAndMount(container, {
type: 'gradient-premium',
icon: 'award-01',
size: 'xl',
});
3. Csak HTML String Generálás
window.pds.iconFeatured.render() – HTML stringet ad vissza DOM-manipuláció nélkül.
Kód megjelenítése
const html = window.pds.iconFeatured.render({
type: 'accent',
icon: 'lightning-01',
size: 'lg',
variant: 'solid',
});
container.innerHTML += html;
Icons (Untitled Icons)
@dsIcon direktíva strukturúrája
@dsIcon('icon-name')
@dsIcon('icon-name', [...args])
hogy testre szabhassuk az ikont:
class
variant
size
light
[class => 'custom-class']
[variant => 'selected-variant']
linesolid
line) vagy kitöltött (solid) ikont szeretnénk használni. Alapértelmezetten
line, így ezt nem kell átadni.
[size => 'selected-size']
defaulttinysmlg
default
tiny
sm
lg
Alapértelmezeten, ha nem adunk át más értéket, akkor a default érték lesz érvényben.
[light => boolean]
[light => true] értéket adjuk át, ha a stroke vastagságát szeretnénk vékonyabbra változtatni.
[hoverIcon => 'untitled-icon-name']
[hoverColor => 'var(--color-token)']
[hoverVariant => 'solid' | 'line']
[animated => '...']
+1: .toggle
+1: .ds-icon-trigger
+1: .ds-icon-hover-disabled
hoverIcon- amennyiben meg van adva, akkor hover esetén ez jelenik meghoverColor- hover esetén a megváltozott szín (ha nincs másodlagos ikon, akkor az elsődleges ikon színe lesz ilyen)hoverVariant- hover esetén a megváltozott variant (ha nincs másodlagos ikon, akkor az elsődleges ikon variantja lesz ilyen).toggle- Ez a class megfordítja az ikonok állapotát (a másodlagosat mutatja).ds-icon-trigger- egy (nem szükségesen közvetlen) parent-ben megadható ez a class, akkor az elemnek a hover eventjére történik meg az ikoncsere.ds-icon-hover-disabled- Ha az ikon megkapja ezt a classt, akkor hoverre nem vált át, csak toggle class-ra- Animálhatóak a fent megadott módosítások. Az
animateda következő értékeket veheti fel:
-[nincs megadva]- default: opacity transient
-false- nincs animáció
-flip-x- horizontális tengelyen forgatás
-flip-y- vertikális tengelyen forgatás
-swipe-left- balra elmozgatás
-swipe-right- jobbra elmozgatás
-swipe-up- felfelé elmozgatás
-swipe-down- lefelé elmozgatás
Kódrészlet
@dsIcon('airplay')
Implementáció
Kódrészlet
@dsIcon('alert-hexagon', ['color' => 'var(--icon-semantic-warning)'])
Implementáció
Kódrészlet
@dsIcon('thermometer-warm', ['light' => true, 'size' => 'lg'])
Implementáció
Kódrészlet
@dsIcon('airplay', ['variant' => 'solid', 'color' => 'var(--icon-semantic-warning)'])
Implementáció
Kódrészlet
@dsIcon('heart', ['variant' => 'line', 'color' => 'red', 'hoverVariant' => 'solid'])
@dsIcon('heart', ['variant' => 'solid', 'color' => 'green', 'hoverColor' => 'red'])
@dsIcon('heart', ['variant' => 'line', 'color' => 'blue', 'hoverIcon' => 'thumbs-up', 'animated' => 'swipe-up'])
@dsIcon('face-smile', ['variant' => 'line', 'color' => 'green', 'hoverIcon' => 'face-sad', 'hoverColor' => 'red', 'hoverVariant' => 'solid'])
Implementáció
Kódrészlet
@dsIcon('face-smile', ['hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
@dsIcon('face-smile', [, 'class' => 'toggle', 'hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
@dsIcon('face-smile', ['class' => 'ds-icon-hover-disabled', 'hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
@dsIcon('face-smile', ['class' => 'ds-icon-hover-disabled toggle', 'hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
Implementáció
Kódrészlet
@dsIcon('face-smile', ['hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
@dsIcon('face-smile', ['class' => 'ds-icon-hover-disabled', 'hoverIcon' => 'face-sad', 'hoverVariant' => 'solid'])
@dsIcon('thumbs-up', ['hoverIcon' => 'thumbs-down', 'animated' => 'swipe-up'])
@dsIcon('thumbs-up', ['class' => 'ds-icon-hover-disabled', 'hoverIcon' => 'thumbs-down', 'animated' => 'swipe-up'])
Implementáció
Kódrészlet
@dsIcon('play', ['hoverIcon' => 'stop',])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => false])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'flip-x'])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'flip-y'])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'swipe-left'])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'swipe-right'])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'swipe-up'])
@dsIcon('play', ['hoverIcon' => 'stop', 'animated' => 'swipe-down'])
Implementáció
Gradient dsIconGradient
A gradient a következő értékeket veheti fel:
- direction - a gradient iránya (to-r, to-l, to-b, to-t, to-br, to-bl, to-tr, to-tl, default (-15deg))
- start - a gradient kezdő színe (CSS color value)
- end - a gradient befejező színe (CSS color value)
Direction
Class + line variant
Class + solid variant
JS dsIconGradient
JS dsIconGradient placeholder
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
| Variant / Weight | tiny | sm | def. | lg |
|---|---|---|---|---|
| line / default | ||||
| line / light | ||||
| solid / default | ||||
| solid / light |
List Item
List Item alkalmazása
<x-pds.list.item> Blade komponens
size- méretactive- aktív állapotdisabled- letiltott állapottype- típusicon- vezető ikontrailingIcon- záró ikonsubtitle- alcímariaControls- ARIA attribútum
Komponens props
iconConfig- ikon konfigurációclass- CSS osztályokhref- link cél
lg - nagy méret (12px 16px padding, ds-body-2 tipográfia)md - közepes méret (8px 16px 8px 8px padding, ds-body-3 tipográfia)sm - kis méret (8px 16px 8px 8px padding, ds-body-4 tipográfia)
Típusok:
default - alapértelmezett lista elemselected - kiválasztható lista elem (chevron-right ikon hozzáadása)
Állapotok:
active - aktív állapot (kék gradient háttér, félkövér szöveg, check-circle ikon)disabled - letiltott állapot (szürke háttér, lock ikon)hover - hover állapot (színkeveréses háttér)keyboard-focused - billentyűzet fókusz (shadow-inset-focus)
Slotok:
slot - fő tartalom (title)iconSlot - egyéni vezető ikon slottrailingIconSlot - egyéni záró ikon slotadditional - további tartalom (pl. badge)
CSS osztályok:
.ds-list-item - fő wrapper osztály.ds-list-item-leading - vezető ikon konténer.ds-list-item-content - tartalom konténer.ds-list-item-title - cím elem.ds-list-item-subtitle - alcím elem.ds-list-item-trailing - záró ikon konténer.ds-list-item-active-icon - aktív állapot ikonja
Megjegyzés: Az aktív állapotnál a trailing ikon automatikusan lecserélődik egy check-circle ikonra. A disabled állapotnál a trailing ikon helyére egy lock ikon kerül CSS maszkként. Az első elem felső sarkain, az utolsó elem alsó sarkain border-radius alkalmazódik.
List item példa
List Item Advanced alkalmazása
<x-pds.list.item-advanced> Blade komponens
A komponens button elemként renderelődik, támogatja az aktív és letiltott állapotokat, valamint opcionális vezető és záró ikonokat.
Az :asLabelFor attibútum beállításával a komponensben található input elemének id attribútumát kell megadni, és a komponens label elemként renderelődik button helyett, így az egész sort lehet kattintani.
Code példa
Modal
Modal komponens használata
Alap beállítások
idtype(basic|alt)position(center|right|fullscreen)
A
id – Ha nincs megadva, generálódik egy egyedi id.A
type határozza meg a modal stílusát (alapértelmezett: basic).A
position a megjelenítés helyét szabályozza (alapértelmezett: center).A modal tartalma Blade-ben a
$slot-ba kerül (a komponens nyitó és záró tagje közé).Fejléc / Lábléc
showHeader,showFootercloseIconnavigationIcontitle,subtitlehtmlTitleslotfooterslot
A
showHeader / showFooter kapcsolja a
szekciókat. (default: true)A
closeIcon az ikon megjelenítését/elrejtését szabályozza. Az ikon bezárja a modalt. (default: true)A
navigationIcon az ikon megjelenítését/elrejtését szabályozza. Erre az ikonra tetszőleges működés köthető. (default: false)A
title és subtitle a fejlécben
megjelenő cím és alcím.A
htmlTitle slot – a fejlécben a cím helyére megadható egyedi HTML, ha szükséges:
<x-slot:htmlTitle>...</x-slot:htmlTitle>A
footer slot – a lábléc tartalma:
<x-slot:footer>...</x-slot:footer>footerHasBorder/:footer-has-border – a footer feletti border bekapcsolása (default: false)footerHasShadow/:footer-has-shadow – a footer feletti shadow bekapcsolása (default: false)Viselkedés
scrollablecloseabledestroyOnClose
A
scrollable engedélyezi a modal törzs görgetését hosszú tartalom
esetén. (default: true)A
closeable ha igaz, a háttérre kattintás is bezárja a modalt (különben
csak a záró ikon/gomb). (default: false)A
destroyOnClose/:destroy-on-close ha igaz, bezáráskor eltávolítja a modalt a DOM-ból. (default: false)
Blade használat
A Blade komponens a teljes HTML struktúrát rendereli server-side (Blade-first). A JS réteg csak az interaktivitást (open/close, events) kezeli.
-
<x-pds.modal id="modal-center" title="Center Modal" position="center">Tartalom</x-pds.modal> -
<x-pds.modal id="modal-right" title="Right Modal" position="right" :closeable="true">Tartalom</x-pds.modal> -
<x-pds.modal id="modal-fs" title="Fullscreen" position="fullscreen" :showFooter="true">Tartalom <x-slot:footer>...</x-slot:footer> </x-pds.modal> -
<x-pds.modal id="modal-custom" :destroy-on-close="true"> <x-slot:htmlTitle>Egyedi cím HTML</x-slot:htmlTitle> Tartalom <x-slot:footer>Footer tartalom</x-slot:footer> </x-pds.modal>
Data attribútumok
data-ds-modal: ComponentRegistry hydration marker a modal wrapper elemen.data-ds-modal-id: a modal egyedi azonosítója (ID-alapú kereséshez).data-ds-modal-target: azonid, amelyik modalt nyissa meg (trigger gombra).data-ds-modal-close: a modálon belüli gomb a bezáráshoz.data-ds-modal-back: navigációs/vissza gomb (modal:navigation event).
JS API
Megnyitás/bezárás:
pds.modal.open(id), pds.modal.close(id)Dinamikus létrehozás és megnyitás:
pds.modal.createAndOpen(config)Dinamikus létrehozás + mount:
pds.modal.createAndMount(document.body, config)Control class elérés:
element._dsInstance vagy pds.modal.instances.get(id)Példa:
pds.modal.createAndOpen({ id: 'dyn-right', title: 'Dinamikus', subtitle: 'Részletek', content: '<p>Tartalom</p>', footer: '<button class=\"ds-btn\" data-ds-modal-close>Bezár</button>', position: 'right', closeable: true, destroyOnClose: true })
Események
A modál elemen (
[data-ds-modal-id="…"] ) a következő egyedi események
érhetők el:modal:open– megnyitáskormodal:close– bezáráskormodal:request-close– bezáráskor van lehetőség a bezárás előtt kódot futtatni vagy megakasztani a bezárástmodal:navigation– navigációs ikon kattintásakor
document.querySelector('[data-ds-modal-id="modal-center"]').addEventListener('modal:open',
e => console.log(e.detail))
Modal típus
(PHP komponensel létrehozva)Ez egy center pozíciójú modal.
Középen jelenik meg a képernyőn.
Ez egy olyan modal amiből bezárásra egy másik modal nyílik meg
Ha a másik modalt bezárjuk, ez a modal is záródik
Ez egy jobbra megnyíló modal.
Jobbról beúszik a képernyőre.
Ez egy teljes képernyős modal.
Az egész képernyőt elfoglalja.
Modal JS-ből létrehozva
(PHP komponens nélkül, JavaScript-ből létrehozva és megnyitva)Modal létrehozása form-al
Lapozó (Pagination)
Lapozó alkalmazása
<x-pds.pagination> Blade komponens
:current- aktuális oldal száma:total- összes oldal száma:visible- látható oldalak száma (alapértelmezett: 3)size- méret (sm/md/lg):paginator- Laravel paginator objektum:compact- kompakt nézet (true/false)class- extra CSS osztályok
Alapvető használat:
<x-pds.pagination :current="1" :total="10" />
Laravel paginator használatával:
<x-pds.pagination :paginator="$users" />
size paraméter
smmdlg
Példa különböző méretekre:
<x-pds.pagination :current="1" :total="10" size="sm" /><x-pds.pagination :current="1" :total="10" size="md" /><x-pds.pagination :current="1" :total="10" size="lg" />
:compact paraméter
false- normál nézet (alapértelmezett)true- kompakt nézet
Példa kompakt módra:
<x-pds.pagination :current="5" :total="20" :compact="true" />
:visible paraméter
Példa:
<x-pds.pagination :current="10" :total="50" :visible="5" />
Ez 5 oldalt fog megjeleníteni az aktuális körül (pl. 8, 9, 10, 11, 12), plusz az első (1) és utolsó (50) oldal, valamint "..." dropdown menük a köztes oldalakhoz.
pagination:change JavaScript event
detail.page- új oldalszám
pagination:change custom eventet küld, amikor
új oldalra navigál a felhasználó. Ez az event használható AJAX alapú tartalombetöltéshez vagy
egyéni navigációs logikához.
Példa JavaScript event kezelésre:
document.querySelector('[data-pagination-id]').addEventListener('pagination:change', (e) => {
console.log('Új oldal:', e.detail.page);
// AJAX betöltés vagy egyéb logika
});
Megjegyzés: Ha paginator objektumot használsz, a komponens automatikusan linkeket generál, így az event mellé a böngésző natív navigációja is működik.
Pagination példák
Pagination – JavaScript Dinamikus Létrehozás
Dinamikus lapozó létrehozás JavaScript-ből. A create() egy DsPagination instance-t ad
vissza — az elem elérhető a ._el property-n keresztül, és feliratkozhatunk a
pagination:change custom eventre.
Elérhető API metódusok
window.pds.pagination.create(options)–DsPaginationinstance,._ela nav elemwindow.pds.pagination.createAndMount(container, options)– Létrehozás, DOM-ba helyezés + DsSelectInput hydratáláswindow.pds.pagination.render(options)– Csak HTML string (nincs hydration)instance.setPage(n)– Helyben frissíti a nav tartalmát az új oldalszámmal; a nav elem és az event listener-ek megmaradnak
Button mód (alapértelmezett): Oldalszámok <button data-page> elemként — SPA / AJAX navigációhoz.
Link mód (pageUrl opció megadva): <a href> elemként generálódnak — szerver oldali navigációhoz.
Mindkét mód egységesen működik a setPage() metódussal.
Konzisztens Blade + JS: A pagination.blade.php komponens
data-size, data-visible, data-compact (és $paginator esetén
data-page-url, data-page-param) attribútumokat rendel a nav-ra,
így setPage() Blade-ből renderelt példányokon is elérhető és konzisztensen működik.
1. Alap Létrehozás – Méret és Visible Variánsok
Különböző méretek (sm, md, lg) és látható oldalak száma
(visible) kombinációi. Az oldalcsere pagination:change eventtel + toast-tal jelzett.
Kód megjelenítése
// Wrapper előbb a DOM-ban, aztán createAndMount — szükséges a DsSelectInput
// < template> lookup (document.getElementById) miatt
container.appendChild(wrapper);
// sm méret – alap
const p1 = window.pds.pagination.createAndMount(wrapper, { current: 6, total: 20, size: 'sm' });
p1._el.addEventListener('pagination:change', e =>
pds.toast.show({ type: 'info', duration: 2000, message: `Oldal: ${e.detail.page}` })
);
// md méret – visible: 5
const p2 = window.pds.pagination.createAndMount(wrapper, { current: 6, total: 20, size: 'md', visible: 5 });
p2._el.addEventListener('pagination:change', e =>
pds.toast.show({ type: 'info', duration: 2000, message: `Oldal: ${e.detail.page}` })
);
2. Kompakt Mód
compact: true esetén az összes oldal egy dropdown-ban jelenik meg
[aktuális] / [összes] formátumban.
Kód megjelenítése
// createAndMount biztosítja a DsSelectInput hydratálást (kompakt dropdown)
container.appendChild(wrapper);
const compact1 = window.pds.pagination.createAndMount(wrapper, {
current: 3, total: 15, compact: true, size: 'sm'
});
compact1._el.addEventListener('pagination:change', e =>
pds.toast.show({ type: 'info', duration: 2000, message: `Kompakt oldal: ${e.detail.page}` })
);
3. Dinamikus Frissítés – setPage()
A setPage(n) metódus helyben frissíti a nav tartalmát — a nav elem és az event listener-ek
megmaradnak, csak a belső gombok cserélődnek. Sokkal egyszerűbb és hatékonyabb
mint a teljes újrarendezés. Működik Blade-ből és JS-ből létrehozott paginátoron is.
Kód megjelenítése
// Egyszer létrehozzuk és mountoljuk
const pager = window.pds.pagination.createAndMount(container, {
current: 1, total: 30, size: 'md', visible: 5,
});
// pagination:change → setPage() egy sorban, nincs újrarendezés
pager._el.addEventListener('pagination:change', e => pager.setPage(e.detail.page));
// _dsInstance konzisztencia: nav elem → instance referencia
console.log(pager._el._dsInstance === pager); // true
4. Link Mód – pageUrl opció
A pageUrl opció megadásával az oldalszám gombok <a href> linkekké válnak —
szerver oldali navigációhoz (full page reload vagy fetch-alapú routing). A pageParam
opció a query paraméter nevét állítja be (default: 'page'). A setPage()
link módban is működik: a data-page-url és data-page-param attribútumokból
(URLSearchParams-szal) rekonstruálja a URL-eket.
Demo megjegyzés: a linkek navigációja le van tiltva — a státuszban látható a generált URL.
Kód megjelenítése
// pageUrl callback → oldalszám gombok < a href> elemekként generálódnak
const pager = window.pds.pagination.createAndMount(container, {
current: 3,
total: 20,
size: 'md',
visible: 5,
pageUrl: p => `/cikkek?oldal=${p}`, // egyedi param név
pageParam: 'oldal', // URLSearchParams paraméter neve setPage()-hez
});
// setPage() link módban: < a href="/cikkek?oldal=N"> elemek generálódnak
pager._el.addEventListener('pagination:change', e => pager.setPage(e.detail.page));
// String pattern alternatíva ('{page}' placeholder):
// pageUrl: '/cikkek?oldal={page}'
// Blade + $paginator esetén automatikus — a nav-on már rajta van:
// data-page-url="$paginator->url(1)"
// data-page-param="$paginator->getPageName()"
5. HTML String Generálás (render-only)
window.pds.pagination.render() — csak HTML stringet ad vissza, nincs hydration.
Statikus megjelenítéshez, szerver-oldali rendereléshez vagy e-mail template-hez.
Figyelem: Gap dropdown-ok (DsSelectInput) ebben az esetben nem lesznek interaktívak.
Kód megjelenítése
// Csak HTML string – nincs DsPagination hydration
const html = window.pds.pagination.render({
current: 5,
total: 20,
size: 'md',
visible: 3,
});
container.innerHTML = html;
Progress Indicator
Progress Indicator alkalmazása
x-pds.progress-indicator komponens
variantsizeprogresscolorvalueLabelloading
Paraméterek:
variant- típus:circular(alapértelmezett),linearsize- méret:sm,md,lgvagy array responsive méretekhez['default' => 'md', 'md' => 'lg']progress- érték: 0-100 közötti szám (alapértelmezett: 0)color- CSS változó vagy hex szín (pl. "var(--surface-semantic-success-inverse)", "#ff3366")valueLabel- egyedi label szöveg (pl. "3/5", "75%")loading- loading állapot animáció (boolean)
Slot támogatás: A komponensben egyedi tartalom helyezhető el (szöveg, badge, ikon, stb.)
Attributes merge: Támogatja a
class és
data-* attribútumok átadását
Circular variant - Méretek és progress értékek
Méret: sm
Méret: md
Méret: lg
Linear variant - Méretek és progress értékek
Méret: sm
Méret: md
Méret: lg
Egyedi színek
Circular - CSS változók
Linear - CSS változók
Hex színek is működnek
Egyedi tartalom - valueLabel és slot
valueLabel használata
Slot tartalom (badge, komponens)
Linear valueLabel
Loading állapot (animált)
Circular loading
Linear loading
Responsive méretezés
Változtasd az ablak méretét hogy lásd a méretváltást!
Circular responsive
Linear responsive
Custom class és data attribútumok (attributes merge)
A komponens támogatja a class, data-*
és egyéb HTML attribútumok átadását az $attributes->merge()
pattern-nel.
JavaScript API használata
Elérhető API metódusok
window.pds.progressIndicator.create(options)- Új komponens létrehozásawindow.pds.progressIndicator.createAndMount(container, options)- Létrehozás és DOM-ba helyezéswindow.pds.progressIndicator.updateProgress(element, progress)- Progress érték frissítésewindow.pds.progressIndicator.updateLabel(element, label)- Label szöveg frissítésewindow.pds.progressIndicator.render(options)- HTML string generálása
1. Dinamikus létrehozás és progress frissítés
Kód megjelenítése
// Komponens létrehozása és DOM-ba helyezése
const container = document.getElementById('js-example-1-container');
const progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: 'md',
progress: 0,
valueLabel: '0%',
color: 'var(--icon-semantic-info)'
});
// Progress frissítése időzítővel
let progress = 0;
const interval = setInterval(() => {
progress += 5;
window.pds.progressIndicator.updateProgress(progressEl, progress);
window.pds.progressIndicator.updateLabel(progressEl, `${progress}%`);
if (progress >= 100) {
clearInterval(interval);
}
}, 200);
2. Loading állapot toggle
Kód megjelenítése
const container = document.getElementById('js-example-2-container');
const progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: 'md',
progress: 25,
loading: true,
color: 'var(--icon-semantic-success)'
});
// Toggle loading class
document.getElementById('js-example-2-toggle').addEventListener('click', () => {
progressEl.classList.toggle('ds-progress-indicator-loading');
});
3. Linear variant dinamikus frissítés
Kód megjelenítése
const container = document.getElementById('js-example-3-container');
const progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'linear',
size: 'md',
progress: 0,
valueLabel: '0 / 100',
color: 'var(--icon-semantic-warning)'
});
// Gombok eseménykezelői
[0, 25, 50, 75, 100].forEach(value => {
const btn = document.getElementById(`js-example-3-${value === 0 ? 'reset' : value}`);
btn.addEventListener('click', () => {
window.pds.progressIndicator.updateProgress(progressEl, value);
window.pds.progressIndicator.updateLabel(progressEl, `${value} / 100`);
});
});
4. Responsive méret dinamikusan
Kód megjelenítése
const container = document.getElementById('js-example-4-container');
let currentSize = 0;
const sizes = ['sm', 'md', 'lg'];
// Kezdeti elem
let progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: 'sm',
progress: 66,
valueLabel: 'sm'
});
// Size váltás
document.getElementById('js-example-4-cycle').addEventListener('click', () => {
currentSize = (currentSize + 1) % sizes.length;
container.innerHTML = '';
progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: sizes[currentSize],
progress: 66,
valueLabel: sizes[currentSize]
});
});
5. Egyedi tartalom (slot) dinamikusan - updateLabel
Kód megjelenítése
const container = document.getElementById('js-example-5-container');
let contentIndex = 0;
const contents = [
'1/5',
'2/5',
'3/5',
'🎉',
];
let progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: 'lg',
progress: 20,
content: contents[0]
});
document.getElementById('js-example-5-update').addEventListener('click', () => {
contentIndex = (contentIndex + 1) % contents.length;
const progress = (contentIndex + 1) * 20;
window.pds.progressIndicator.updateProgress(progressEl, progress);
window.pds.progressIndicator.updateLabel(progressEl, contents[contentIndex]);
});
6. Slot-szerű funkcionalitás - setSlot (Content)
Kód megjelenítése
const container = document.getElementById('js-example-6-container');
// Progress indicator létrehozása
const progressEl = window.pds.progressIndicator.createAndMount(container, {
variant: 'circular',
size: 'lg',
progress: 66
});
// Gomb klikkelés
document.getElementById('js-example-6-apply').addEventListener('click', () => {
// Content container lekérése (mint Blade slot)
const contentContainer = window.pds.progressIndicator.getSlot(progressEl);
// DOM elemek létrehozása és hozzáadása
const span = document.createElement('span');
span.textContent = '✓';
span.style.fontSize = '24px';
span.style.color = 'var(--icon-semantic-success)';
// Vagy használd az setSlot metódust
window.pds.progressIndicator.setSlot(progressEl, span);
// Progress frissítése
window.pds.progressIndicator.updateProgress(progressEl, 100);
});
Segmented Control
Segmented Control alkalmazása
x-pds.segmented-control
variantnameclassanimationhasQueryquery
x-pds.segmented-control.item
keyactiveiconiconColoriconVariantdisabledonclickbadgeContentbadgeTypebadgeBgColorbadgeTextColor
variant értékei lehetnek:
fill,
equal,
fill equal.
Fill esetén: az item-ek kitöltik a teljes szélességet, de nem egyenlő szélességűek.
Equal esetén: minden item szélességét a legnagyobb elem méretére állítja.
Fill Equal esetén: minden item egyenlő szélességű, és a teljes szélességet kitölti.
Az ikon mindig a bal oldalon jelenik meg, 16x16 px méretben.
Az ikon
iconVariant lehetséges értékei: line, solid. Alapértelmezett: line.
Az ikon
iconColor paraméterrel egyedi színt kaphat. Ha nincs megadva, a szöveg színét örökli.
A badge a
badgeContent attribútummal adható meg.
A badge
badgeType értékei: basic, advanced, highlighted, semantic, dot.
Az
animation paraméter alapértelmezetten true. false értékkel kikapcsolható az indicator animáció.
A
hasQuery paraméter (boolean, alapértelmezett: false) bekapcsolja az URL query paraméter szinkronizációt.
A
query paraméter (string, alapértelmezett: "segment") az URL query paraméter nevét határozza meg.
Dinamikus tartalom: A segmented control automatikusan kezeli a tartalom váltást.
A
name attribútummal azonosítjuk a kontrollt, a tartalom elemeken data-segmented-content="name" és data-key="key" attribútumokkal kapcsoljuk össze.
Kódrészlet
<x-pds.segmented-control name="basic-example" variant="fill equal">
<x-pds.segmented-control.item key="option1" :active="true">
Első opció
</x-pds.segmented-control.item>
<x-pds.segmented-control.item key="option2">
Második opció
</x-pds.segmented-control.item>
<x-pds.segmented-control.item key="option3">
Harmadik opció
</x-pds.segmented-control.item>
</x-pds.segmented-control>
<div data-segmented-content="basic-example" data-key="option1">
Első opció tartalma
</div>
<div data-segmented-content="basic-example" data-key="option2">
Második opció tartalma
</div>
<div data-segmented-content="basic-example" data-key="option3">
Harmadik opció tartalma
</div>
Implementáció
Segmented Control típusok
Modalban (mobil tesztelhetőség miatt)
Ikonokkal és badge-ekkel
Badge típusok
Egyedi színek és disabled állapot
URL Query paraméterekkel
A segmented control szinkronizálható az URL query paramétereivel. Ha a :hasQuery="true" prop meg van adva:
- A kiválasztott elem kulcsa bekerül az URL-be query paraméterként
- Oldal betöltéskor az URL-ből olvasható az aktív elem
- A böngésző vissza/előre gombjai is működnek
- Több control is használható különböző query paraméterekkel
A query prop-pal testreszabható a query paraméter neve (alapértelmezett: "segment").
Semantic Card
Semantic Card alkalmazása
x-pds.semantic-card
typetitledescriptioniconcompactclass
type értékei lehetnek:
warning,
success,
alert,
info,
neutral,
brand,
purple,
premium-purple.
A
title, description, icon értékek opcionálisak.
A
compact mód esetén nem alul, hanem jobb oldalt jelenik meg a műveleti sáv, alapértelmezetten false.
A
class értéke opcionális, a kártya további stílusát (pl. méretezés) befolyásolják.closeablecloseId
compact módban nem lehet bezárni, akkor sem, ha át van neki adva a paraméter.
Ha simán átadjuk neki a
closeable="true" értéket, akkor amint rákattintunk, eltűnik, de az oldal újratöltésénél alapértelmezetten újra megjelenik.
Ha átadunk egy egyedi
closeId azonosítót, bezáráskor a kártya egy semantic-card:close eseményt dispatch-el (detail-ben elérhető a closeId és a card element).
actionLabelactionaction2Labelaction2linkLabellinklink2Labellink2<actionSlot>
A
*Label értékaként kell megadni a gomb szövegét, a *2* értékek pedig a másodlagos gombot jelentik.
A műveletet a
* értékadásával lehet hozzárendelni a hozzá tartozó *Label-hez.
A
compact módban csak az elsődleges akciót lehet hozzárendelni (a másodlagos nem jelenik meg).
Ha egyedi template-t szeretnénk alkalmazni, akkor a
<x-slot name="actionSlot">[...]</x-slot>-on belül kell elhelyezni a template-t.
helpLabeltooltiphelpTrigger
helpLabel értékét kell megadni.
A
tooltip értékét átadva egy tooltip fog megjelenni a helpLabel szöveggel, ha rákattintunk a fentebb megadott gombra.
- nincs még a tooltip implementálva!
Ha a
helpTrigger értéket adjuk át, akkor egyedi JS eseményt fogunk elérni, aminek a trigger-e a helpLabel gombja lesz.
Semantic Card típusok
Mindenes
Ezt a kártyát a felhasználó bezárhatja, ha a bezárás gombra kattint. Az oldal frissítése után a kártya újra megjelenik.Linkes
Beállítható, hogy ne event-et süssünk el, hanem egy adott route-ra navigáljunk, ha nem action-t adunk meg hanem link-et.Kompakt
FYI: A kompakt sosem zárható be.Custom slotos
Megadhathatóak egyedi akció értékek, ebben az esetben az 'actionSlot' névvel ellátott slotban kell elhelyezni a hozzá tartozó templatet.Karcsú
Ahhoz, hogy ne csak a képernyőkép alapján legyen 'mobilbarát', hanem a befogó terület alapján, ahhoz a szülő blokknak szükséges megadni a 'ds-semantic-card-wrapper/ds-semantic-card-container' class valamelyikét.Információs
Lehet akár ikon és akció nélkül is, ha csak információt szeretnénk megjeleníteni.Információs
Ez pedig egy kompakt, akció nélküli.Lehet cím nélkül is.
Ez pedig egy kompakt, cím nélküli.
Type: warning
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: warning - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: warning - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: success
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: success - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: success - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: alert
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: alert - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: alert - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: info
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: info - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: info - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: neutral
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: neutral - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: neutral - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: brand
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: brand - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: brand - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: purple
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: purple - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: purple - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: premium-purple
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: premium-purple - Compact
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Type: premium-purple - Responsive
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris.Shadow
Spacing (figma)
Spacing class strukturúrája
[level]
[level] |
zero |
4xs |
3xs |
2xs |
xs |
sm |
md |
lg |
xl |
2xl |
3xl |
4xl |
5xl |
6xl |
7xl |
8xl |
9xl |
0 |
2 |
4 |
8 |
12 |
16 |
20 |
24 |
32 |
40 |
48 |
56 |
64 |
72 |
96 |
104 |
128 |
[desktop] |
0px |
2px |
4px |
8px |
12px |
16px |
20px |
24px |
32px |
40px |
48px |
56px |
64px |
72px |
96px |
104px |
128px |
|||||||||||||||||
[mobile] |
0px |
2px |
2px |
4px |
8px |
12px |
16px |
20px |
24px |
32px |
40px |
40px |
48px |
56px |
64px |
72px |
72px |
Padding
ds-p-[level]ds-py-[level]ds-px-[level]ds-pt-[level]ds-pl-[level]ds-pr-[level]ds-pb-[level]
A level-ek között megtalálhatók a namingelt értékek (pl.: xs, sm, lg) mellett a fix (pl.: 4, 8, 32) értékek is, amelyeket kifejezetten akkor használunk, ha egy komponens úgy van megalkotva, hogy szándékosan ne függjön az eszköz méretétől ( - ez a designerek által meghozott döntés, ha ilyet látsz pl. egy layoutok közötti elemen, akkor ott ne ezt használd). Ezekben az esetben nem lehet a level-eket használni, hanem a fix értékek közül választhatunk.
Margin
ds-m-[level]ds-my-[level]ds-mx-[level]ds-mt-[level]ds-ml-[level]ds-mr-[level]ds-mb-[level]
Gap
ds-gap-[level]
ds-flex-column vagy ds-flex-column elrendezést alkalmazunk, és közöttük távolságot
szeretnénk beállítani.
Padding példák
Gap példák
Stepper Horizontal
Stepper Horizontal alkalmazása
.ds-stepper-horizontal class / komponens
.ds-stepper-horizontal-item.active
x-pds.stepper-horizontal Blade komponens
actualSteplockedProgressnamevalidationFunctioneventNamedata-stepper-id(attribútum)
ds-stepper-horizontal-change eseményt küld, amely tartalmazza az index-et, value-t és az elemet.
Paraméterek:
actualStep - aktuális lépés száma (1-based, default: 1)lockedProgress - ha true, akkor az aktív lépés után minden lépés disabled lesz (default: false)name - folyamat neve, amely a mobil nézetben jelenik megvalidationFunction - ajánlott validációs függvény neve (window objektumon elérhető), amely true/false értéket ad vissza. Ha false, a navigáció blokkolva van.eventName - opcionális globális esemény neve validációhoz (csak speciális esetekben, ha több listener kell). A validationFunction használata ajánlott.data-stepper-id - opcionális azonosító több stepper szinkronizálásához (attribútumként használható, konzisztens a data-stepper-back és data-stepper-next attribútumokkal)
Állapotok:
active - aktív stepper, gradient háttérreldisabled - inaktív, nem kattinthatóhover - box körbe Surface/State/Default/weak-hover háttérrel
Funkciók:
- Aktív elem automatikus jelzése
- Ikonok támogatása a stepper elemekben
- CustomEvent dispatch stepper váltáskor (
ds-stepper-horizontal-change)- Mobil nézet támogatás (max-width: 768px) - dinamikus lista jelenik meg
Külső navigációs gombok:
Külső gombokkal is vezérelhető a stepper. A gombokhoz a következő data attribútumokat kell megadni:
data-stepper-back - a stepper elem CSS selector-ja (pl. "[data-stepper-id=myStepper]") az előző gombhozdata-stepper-next - a stepper elem CSS selector-ja (pl. "[data-stepper-id=myStepper]") a következő gombhozAz érték CSS selector (pl.
[data-stepper-id=myStepper]). Egy gomb több stepper-t is irányíthat, ha több stepper is megfelel a selector-nak.Példa:
<button data-stepper-back="[data-stepper-id=myStepper]">Előző</button>Példa:
<button data-stepper-next="[data-stepper-id=myStepper]">Következő</button>
Megjegyzés: A komponens JavaScript automatikusan inicializálódik minden
.ds-stepper-horizontal-wrapper elemen. A stepper-horizontal-item elemek <button> típusúak.
x-pds.stepper-horizontal.item Blade komponens
iconiconConfig
.ds-stepper-horizontal konténeren belül használható. Automatikusan <button> elemet renderel a megfelelő osztályokkal és attribútumokkal.
Tulajdonságok:
icon - ikon neve (opcionális), amely a stepper szövege előtt jelenik megiconConfig - ikon konfigurációs tömb (default: ['size' => 'sm'])Slotok:
$slot - fő tartalom (stepper felirat)$additional - további tartalom a slot után
Használat példa:
<x-pds.stepper-horizontal.item icon="home">Első oldal</x-pds.stepper-horizontal.item>
Stepper Horizontal , szabad átkattintás
Stepper Horizontal , lockolt
Lockolt folyamat: Az aktív lépés után minden lépés disabled lesz. A gombokkal vagy kattintással vissza lehet lépni, de előre csak az aktív lépésig lehet menni.
Stepper Horizontal, validációs függvénnyel
Validációs függvény: A stepper meghívja a megadott függvényt navigáció előtt. Ha a függvény false-t ad vissza, a navigáció blokkolva van. Ha true-t (vagy bármi mást), a navigáció engedélyezve van.
A példában egy confirm ablak jelenik meg, ami megerősítést kér a navigáció előtt.
Stepper Horizontal, event validációval
Event validáció: A stepper csak akkor lép tovább, ha a custom event nem hívja meg a preventDefault()-et vagy nem ad vissza false értéket.
A példában egy confirm ablak jelenik meg, ami megerősítést kér a navigáció előtt.
Stepper Horizontal , tartalom megjelenítés lépés alapján
Válassz egy lépést a fenti stepper-ből vagy használd az Előző/Következő gombokat.
Stepper Horizontal , több stepper ugyanazokkal a gombokkal
Válassz egy lépést a fenti stepper-ből vagy használd az Előző/Következő gombokat.
Példa: Mindkét stepper ugyanazzal a data-stepper-id="multiStepper" értékkel van ellátva.
A gombok mindkét stepper-t egyszerre irányítják. A tartalom mindkét stepper változására reagál.
Tab
Tab alkalmazása
.ds-tab class / komponens
.ds-tab-item.active.ds-tab-sm
x-pds.tab Blade komponens
sizeicondisabled
ds-tab-change eseményt küld, amely tartalmazza az index-et, value-t és az elemet.
Méretek:
sm - kisebb padding (8px 14px) és ds-body-3 tipográfiadefault (md) - normál padding (8px 16px) és ds-body-2 tipográfia
Állapotok:
active - aktív tab, alsó border láthatódisabled - inaktív, nem kattinthatóhover/focus - interaktív állapotok vizuális visszajelzéssel
Funkciók:
- Automatikus horizontális görgetés egérgörgővel (snap scroll)
- Aktív elem automatikus központosítása/scroll-ba hozása
- Ikonok támogatása a tab elemekben
- CustomEvent dispatch tab váltáskor (
ds-tab-change)
Megjegyzés: A komponens JavaScript automatikusan inicializálódik minden
.ds-tab elemen. A tab-item elemek <button> típusúak.
x-pds.tab.item Blade komponens
iconiconConfigclassdisabled
.ds-tab konténeren belül használható. Automatikusan <button> elemet renderel a megfelelő osztályokkal és attribútumokkal.
Tulajdonságok:
icon - ikon neve (opcionális), amely a tab szövege előtt jelenik megiconConfig - ikon konfigurációs tömb (default: ['size' => 'sm'])class - további CSS osztályok (pl. 'active' az aktív állapothoz)disabled - boolean, letiltja a tab elemet (default: false)
Slotok:
$slot - fő tartalom (tab felirat)$additional - további tartalom a slot után
Használat példa:
<x-pds.tab.item icon="home" class="active">Kezdőlap</x-pds.tab.item>
Tab típusok
Amikor nem fér ki széltében
Modalban (mobil tesztelhetőség miatt)
Tags
Tag komponens használata
Alap beállítások
colorsizecontentcustomClass
A
color (alapértelmezett: primary)
A
size (alapértelmezett: md) A
content a címke felirata. A
customClass további CSS osztályok hozzáadására szolgál.
Állapotok
activeStateactiveSubtleactionType
A
activeState határozza meg az induló aktív állapotot. A
activeSubtle finomabb aktív megjelenést ad. A
actionType lehet toggle
(kattintásra vált) vagy close (bezáró ikon eltávolítja a taget).
Ikonok
icon+iconVariantcloseIcon+closeIconVariant
Az
icon a címke elé kerülő ikon neve, az iconVariant
a változata (line vagy solid). A
closeIcon (alap: x-close) és closeIconVariant a bezáró ikon beállításai.
Azonosító
id
Az
id a tag egyedi azonosítója (opcionális, automatikusan generált
uniqid).
Adattulajdonságok
dataAttributes
Objektum formában adható meg, a kulcsok
data-* attribútumként
kerülnek a tagre. Példa: ['id' => 12, 'type' => 'skill'].
Elérhetőség
closeAriaLabel
A tag gombként viselkedik (
role="button"), az állapot aria-pressed attribútummal frissül. Bezárás esetén a bezáró ikonhoz megadható
closeAriaLabel.
Események és hidratáció
A tag komponens automatikusan hidratálódik a ComponentRegistry által.
Nincs szükség manuális JS inicializálásra.
JavaScript események
Bezáráskor (ha
actionType="close") a tag eltávolítja magát és egy
tag:deleted custom event fut le.Eseményre feliratkozás:
document.addEventListener('tag:deleted', function (event) {
console.log('Tag ID:', event.detail.tagId);
console.log('Tartalom:', event.detail.tagContent);
})
Blade használat
-
<x-pds.tag content="Marketing" color="secondary" size="sm" /> -
<x-pds.tag content="Design" :activeState="true" icon="star" iconVariant="solid" /> -
<x-pds.tag content="Törölhető" actionType="close" closeAriaLabel="Címke törlése" /> -
<x-pds.tag content="Skill" :dataAttributes="['id' => 12, 'type' => 'skill']" />
AJAX után hidratálás
A tag-ek automatikusan hidratálódnak az oldal betöltésekor, de AJAX után manuálisan is hidratálhatod:
// Hidratáld az AJAX konténerben lévő tag-eket
ComponentRegistry.hydrateComponent('DsTag', document.getElementById('ajax-container'));
Toggle Interaktív Tag
Close Interaktív Tag
Tag Button
Tag Basic
Tag highlighted
JavaScript Dynamic Tag Creation
Dinamikus tag létrehozás JavaScript-ből (AJAX/fetch hívásokhoz, client-side rendering)
1. Egyszerű Tag Létrehozás
window.pds.tag.create() - Létrehoz egy tag-et, ami készen áll a DOM-ba való
beszúrásra
// 1. Egyszerű létrehozás
const tag = window.pds.tag.create({
content: 'JavaScript Tag',
color: 'primary'
});
container.appendChild(tag.element);
2. Létrehozás és Hozzáadás Egy Lépésben
window.pds.tag.createAndMount(container, options) - Létrehoz és azonnal
hozzáad egy konténerhez
// 2. Létrehozás és hozzáadás
window.pds.tag.createAndMount(container, {
content: 'Quick Tag',
color: 'secondary',
icon: 'star-01'
});
3. Tag Ikonnal és Interakcióval
Tag létrehozása ikonnal, close action-nel, eseményfigyeléssel
// 3. Eseményfigyelés
document.addEventListener('tag:deleted', (e) => {
console.log('Törölve:', e.detail.tagContent);
});
4. Tömeges Létrehozás (AJAX Szimuláció)
Több tag létrehozása egyszerre (pl. szerver válaszból)
// 4. AJAX példa
fetch('/api/tags')
.then(res => res.json())
.then(tags => {
tags.forEach(tagData => {
window.pds.tag.createAndMount(container, {
content: tagData.name,
color: tagData.color,
actionType: 'close'
});
});
});
5. Csak HTML Generálás (Hidratálás Nélkül)
window.pds.tag.render() - Csak HTML stringet ad vissza, későbbi
hidratáláshoz
// 5. Csak HTML (későbbi hidratáláshoz)
const html = window.pds.tag.render({ content: 'HTML Only' });
container.innerHTML += html;
Toast
Toast alkalmazása
x-pds.toast.wrapper
initconfigWrappershow
Nem probléma, ha véletlenül több helyen is implementálva, mert csak egyszer definiálódik.
Az inicializálás a
pds.toast.init() metódussal történik, ami a DOMContentLoaded eseményre van bekötve, ez automatikusan megtörténik a laravel komponens implenentásával.Amennyiben az oldalbetöltésre azonnal szeretnénk megjeleníteni üzenetet, akkor a
window.onload eseményre kell bekötni a pds.toast.show() metódust.pds.toast.configWrapper()
positionstackoffsetelevation+1: force-init
x-pds.toast.wrapper attribútumaiként is.position - megadható szabad szavasan a bottom, top valamint a right, left, center értékek.stack - a megjelenített toast üzenetek számát határozza meg, alapértelmezetten 5.offset - az oldal szélétől való eltérés, x, y értékadásával, amelyek az átadott egységgel (pl.: px, rem) értendők.elevation - z-index beállítása, amennyiben van valami, ami magasabban van, mint amennyire a toast wrapper van pozicionálva, akkor ez a paraméter segít, hogy a toast wrapper mindig a legmagasabb legyen.+1: force-init - Ez az egy extrán átadható a laravel komponensen keresztül. Mivel a wrapper csak egyszer inicializálódik, ezért az átadott paraméterek nem kerülnek figyelembe véve, hacsak nem adjuk át ezt neki. Ez a pds.toast.configWrapper() meghívását tudja helyettesíteni.pds.toast.show()
typemessageiconclosablebuttonduration
type - Itt a következő értékeket adhatjuk meg: info, warning, alert, success, neutral (ez a default érték).message - a megjelenítendő üzenet szövege.icon - a megjelenítendő ikon neve, a @dsIcon() metódusban megadott név.closable - az üzenet bezárásának lehetősége, alapértelmezetten true.button - egy gomb megjelenítése a toast üzenetben, amelynek a szövege (text) és az eseménye (action) megadható.dynamic - az üzenet megjelenítési ideje, amelyet az üzenet alapján számít ki. Ez az alapértelmezett. Amennyiben van megadott extra gomb, akkor van még hozzá tartozó extra idő.duration - az üzenet megjelenítési ideje, ha nem dinamikus, alapértelmezetten 3000ms. Ha dinamikus, és meg van adva, akkor ez a minimum idő, amíg megjelenik, plusz erre számítja az üzenet hosszát.pds.toast.clearAll()
Toast típusok
Kattints a megjelenítéséhezToast Wrapper pozicionálás
Toast Wrapper pozicionálás
Tooltips
Tooltip attribútumok strukturája
data-tooltipdata-tooltip-placementtop, bottom, left, right, valamint a start és end és ezek kombinációi (top-start, top-end, stb.). Alapértelmezett: top.
data-tooltip-titledata-tooltip-html<strong>, <em>) támogatottak.
data-tooltip-closeabledata-tooltip-btn
+ kapcsolódó attribútumok
ds-btn-inverse gomb.
- Callback opciók (válassz egyet):
data-tooltip-btn-onclick- Callback funkció (inline kód vagy globális funkció neve)data-tooltip-btn-callback- Callback funkció (inline kód vagy globális funkció neve)
data-tooltip-btn-close- Ha"false", nem záródik be a tooltip a gomb után (alapértelmezett:"true")
data-tooltip-ellipsisdata-tooltip-triggerhover (alapértelmezett) vagy click. Closeable tooltip-ok automatikusan click trigger-t használnak.
data-tooltip-themeJavaScript API
pds.tooltip.attach()pds.tooltip.attach(element, content, options)
Options objektum:
placement- Pozíciótitle- Címhtml- HTML tartalom engedélyezésecloseable- Bezárható-ebuttonText- Action button szövegebuttonCallback- Action button funkciójabuttonClose- Bezáródjon-e button után (default: true)
pds.tooltip.detach()pds.tooltip.detach(element)
pds.tooltip.scan()data-tooltip attribútumokhoz.
pds.tooltip.scan(containerElement)
pds.tooltip.scanEllipsisTooltips()pds.tooltip.scanEllipsisTooltips(containerElement)
Typography (figma)
Display
Display Body
Heading (ds-heading-1,...)
Heading (h1,..)
Heading 1
Heading 2
Heading 3
Heading 4
Heading 1
Heading 2
Heading 3
Heading 4
Body text
Body bold text
Body link text
Body bold link text
Label
Action
Typography coloring
A példák a ds-heading-3 classon vannak bemutatva, de működnek bármelyik typography classon.
Az egyetlen, ami eltér, hogy a classokhoz egyedi css változó nevek eltérnek, mely a typography nevét követi.
- heading:
--ds-heading-color - body:
--ds-body-color || --ds-body-color-link - display:
--ds-display-color - display body:
--ds-display-body-color || --ds-display-body-color-link - action:
--ds-action-color - label:
--ds-label-color
Alapértelmezett szín (default)
Minden typography class rendelkezik egy alapértelmezett színnel, amely a design system default színének felel meg.
Override ds-color-* class alkalmazásával
A ds-color-* class alkalmazásával felülírhatjuk a typography class színét, az előre definiált színek közül.
Override inline style-al (custom)
A inline style-al segítségével felülírhatjuk a typography class színét, a CSS változók segítségével.
Marad default szín, akkor is ha a parent color brand-additional
A parent-ben definiált color öröklődik a typography classra, megmarad a default szín.