@navservice/web-components 1.0.0

package/build/es/index.js

@@ -0,0 +1,421 @@
+import "./rslib-runtime.js";
+import { LitElement, html } from "lit";
+import { property } from "lit/decorators.js";
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (0 === kind) if (isPrivate) {
+            get = desc.get;
+            set = desc.set;
+        } else {
+            get = function() {
+                return this[name];
+            };
+            set = function(v) {
+                this[name] = v;
+            };
+        }
+        else if (2 === kind) get = function() {
+            return desc.value;
+        };
+        else {
+            if (1 === kind || 3 === kind) get = function() {
+                return desc.get.call(this);
+            };
+            if (1 === kind || 4 === kind) set = function(v) {
+                desc.set.call(this, v);
+            };
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+    }
+    function assertCallable(fn, hint) {
+        if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (1 === kind) {
+            if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+            if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+            if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+        } else if ("function" !== type) {
+            var hint;
+            hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) desc = 0 === kind || 1 === kind ? {
+            get: decInfo[3],
+            set: decInfo[4]
+        } : 3 === kind ? {
+            get: decInfo[3]
+        } : 4 === kind ? {
+            set: decInfo[3]
+        } : {
+            value: decInfo[3]
+        };
+        else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+        if (1 === kind) value = {
+            get: desc.get,
+            set: desc.set
+        };
+        else if (2 === kind) value = desc.value;
+        else if (3 === kind) value = desc.get;
+        else if (4 === kind) value = desc.set;
+        var newValue, get, set;
+        if ("function" == typeof decs) {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                if (0 === kind) init = newValue;
+                else if (1 === kind) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+            }
+        } else for(var i = decs.length - 1; i >= 0; i--){
+            var dec = decs[i];
+            newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                var newInit;
+                if (0 === kind) newInit = newValue;
+                else if (1 === kind) {
+                    newInit = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+                if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                else if ("function" == typeof init) init = [
+                    init,
+                    newInit
+                ];
+                else init.push(newInit);
+            }
+        }
+        if (0 === kind || 1 === kind) {
+            if (void 0 === init) init = function(instance, init) {
+                return init;
+            };
+            else if ("function" != typeof init) {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (0 !== kind) {
+            if (1 === kind) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (2 === kind) desc.value = value;
+            else if (3 === kind) desc.get = value;
+            else if (4 === kind) desc.set = value;
+            if (isPrivate) if (1 === kind) {
+                ret.push(function(instance, args) {
+                    return value.get.call(instance, args);
+                });
+                ret.push(function(instance, args) {
+                    return value.set.call(instance, args);
+                });
+            } else if (2 === kind) ret.push(value);
+            else ret.push(function(instance, args) {
+                return value.call(instance, args);
+            });
+            else Object.defineProperty(base, name, desc);
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (Array.isArray(decInfo)) {
+                var kind = decInfo[1];
+                var name = decInfo[2];
+                var isPrivate = decInfo.length > 3;
+                var isStatic = kind >= 5;
+                var base;
+                var initializers;
+                if (isStatic) {
+                    base = Class;
+                    kind -= 5;
+                    staticInitializers = staticInitializers || [];
+                    initializers = staticInitializers;
+                } else {
+                    base = Class.prototype;
+                    protoInitializers = protoInitializers || [];
+                    initializers = protoInitializers;
+                }
+                if (0 !== kind && !isPrivate) {
+                    var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                    var existingKind = existingNonFields.get(name) || 0;
+                    if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                    if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                    else existingNonFields.set(name, true);
+                }
+                applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+            }
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) ret.push(function(instance) {
+            for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+            return instance;
+        });
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (void 0 !== nextNewClass) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function(targetClass, memberDecs, classDecs, parentClass) {
+        if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _dec1, _init_open, _init_setOnEscClose, _initProto;
+_dec = property({
+    type: Boolean
+}), _dec1 = property({
+    type: Boolean
+});
+class MyElement extends LitElement {
+    static{
+        ({ e: [_init_open, _init_setOnEscClose, _initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                1,
+                "open"
+            ],
+            [
+                _dec1,
+                1,
+                "setOnEscClose"
+            ]
+        ], []));
+    }
+    #___private_open_1 = (_initProto(this), _init_open(this, false));
+    get open() {
+        return this.#___private_open_1;
+    }
+    set open(_v) {
+        this.#___private_open_1 = _v;
+    }
+    #___private_setOnEscClose_2 = _init_setOnEscClose(this, true);
+    get setOnEscClose() {
+        return this.#___private_setOnEscClose_2;
+    }
+    set setOnEscClose(_v) {
+        this.#___private_setOnEscClose_2 = _v;
+    }
+    createRenderRoot() {
+        return this;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        window.addEventListener('keydown', this.handleKeydown);
+    }
+    disconnectedCallback() {
+        window.removeEventListener('keydown', this.handleKeydown);
+        super.disconnectedCallback();
+    }
+    handleKeydown = (event)=>{
+        if (this.setOnEscClose && 'Escape' === event.key && this.open) this.closeModal();
+    };
+    openModal = ()=>{
+        this.open = true;
+    };
+    closeModal = ()=>{
+        this.open = false;
+    };
+    clearAndClose = ()=>{
+        console.log('Clear acionado');
+        this.open = false;
+    };
+    render() {
+        return html`
+      <div class="min-h-screen flex flex-col items-center justify-center gap-3 bg-gradient-to-br from-gray-50 to-gray-100">
+        <h1 class="text-3xl font-semibold tracking-tight text-gray-900">
+          Rsbuild + Lit
+        </h1>
+        <p class="text-sm text-gray-500">
+          Interface minimalista, rápida e moderna.
+        </p>
+
+        <button
+          class="mt-4 inline-flex items-center justify-center rounded-lg border border-gray-300 bg-white px-5 py-2.5 text-sm font-medium text-gray-900 shadow-sm transition hover:bg-gray-50 hover:shadow-md focus:outline-none focus:ring-2 focus:ring-indigo-500"
+          @click=${this.openModal}
+        >
+          Abrir modal lateral
+        </button>
+      </div>
+
+      <!-- Overlay -->
+      <div
+        class="fixed inset-0 z-40 bg-black/40 backdrop-blur-sm transition-opacity duration-300
+        ${this.open ? 'opacity-100 pointer-events-auto' : 'opacity-0 pointer-events-none'}"
+        @click=${this.closeModal}
+      ></div>
+
+      <!-- Drawer -->
+      <aside
+        class="fixed right-0 top-0 z-50 h-full w-full max-w-md bg-white shadow-2xl
+        transition-transform duration-300 ease-out
+        ${this.open ? 'translate-x-0' : 'translate-x-full'}"
+      >
+        <div class="flex h-full flex-col p-6">
+          <div class="mb-4">
+            <h2 class="text-lg font-semibold text-gray-900">
+              Confirmação
+            </h2>
+            <p class="mt-1 text-sm text-gray-500">
+              Este é um modal lateral com UX inspirada em Vercel e Cloudflare.
+            </p>
+          </div>
+
+          <div class="flex-1"></div>
+
+          <div class="flex justify-end gap-3 border-t pt-4">
+            <button
+              class="rounded-md px-4 py-2 text-sm font-medium text-gray-600 hover:bg-gray-100 transition"
+              @click=${this.clearAndClose}
+            >
+              Cancelar
+            </button>
+
+            <button
+              class="rounded-md bg-indigo-600 px-4 py-2 text-sm font-medium text-white shadow-sm hover:bg-indigo-700 transition"
+              @click=${this.closeModal}
+            >
+              Confirmar
+            </button>
+          </div>
+        </div>
+      </aside>
+    `;
+    }
+}
+customElements.define('my-element', MyElement);
+export { MyElement };

package/build/es/my-element.d.ts

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+export declare class MyElement extends LitElement {
+    accessor open: boolean;
+    accessor setOnEscClose: boolean;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    openModal: () => void;
+    closeModal: () => void;
+    clearAndClose: () => void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/build/es/rslib-runtime.js

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };