@nuraly/runtime 0.1.4 → 0.1.5

package/dist/{SmartAttributeHandler-hoSLpm1Y.js → SmartAttributeHandler-C9vS-cHW.js}

@@ -1,4 +1,4 @@
-import { i as b, n, r as p, h as v, k as h, s as C, t as y, D as m } from "./micro-app-entry-CI1Rupdh.js";
+import { i as b, n, r as p, h as v, k as h, s as C, t as y, D as m } from "./micro-app-entry-DDsAWUJh.js";
 var g = Object.defineProperty, S = Object.getOwnPropertyDescriptor, l = (e, t, i, a) => {
   for (var o = a > 1 ? void 0 : a ? S(t, i) : t, u = e.length - 1, d; u >= 0; u--)
     (d = e[u]) && (o = (a ? d(t, i, o) : d(o)) || o);

package/dist/SmartAttributeHandler-u-ZHGueR.js

@@ -0,0 +1,193 @@
+import { css, LitElement, html, nothing } from 'lit';
+import { property, state, customElement } from 'lit/decorators.js';
+import { styleMap } from 'lit/directives/style-map.js';
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let SmartAttributeCodeeditor = class extends LitElement {
+  constructor() {
+    super();
+    this.containerStyle = {
+      background: "white",
+      width: "700px",
+      height: "250px"
+    };
+    this.debounceTimeout = null;
+    this.data = "";
+    this.isEditorLoaded = true;
+    this.handleCodeEditorChange = this.handleCodeEditorChange.bind(this);
+  }
+  // No dynamic import needed; CodeEditor is statically registered above
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+    }
+  }
+  render() {
+    return html`
+      <div style=${styleMap(this.containerStyle)}>
+        ${this.isEditorLoaded ? html`
+              <code-editor
+                theme="vs"
+                @change=${(event) => {
+      const {
+        detail: { value }
+      } = event;
+      this.debounce(() => this.handleCodeEditorChange(value), 1e3);
+    }}
+                .code=${this.value}
+                language="javascript"
+              ></code-editor>
+            ` : html`<p>Loading editor...</p>`}
+        <markdown-renderer markdown=${this.data}></markdown-renderer>
+      </div>
+    `;
+  }
+  handleCodeEditorChange(value) {
+    const submitEvent = new CustomEvent("change", {
+      detail: { value },
+      bubbles: true,
+      composed: true
+    });
+    this.dispatchEvent(submitEvent);
+  }
+  debounce(callback, delay) {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+    }
+    this.debounceTimeout = setTimeout(() => {
+      this.debounceTimeout = null;
+      callback();
+    }, delay);
+  }
+};
+SmartAttributeCodeeditor.styles = [
+  css`
+      :host {
+        display: block;
+      }
+    `
+];
+__decorateClass$1([
+  property()
+], SmartAttributeCodeeditor.prototype, "value", 2);
+__decorateClass$1([
+  property({ type: Object })
+], SmartAttributeCodeeditor.prototype, "containerStyle", 2);
+__decorateClass$1([
+  state()
+], SmartAttributeCodeeditor.prototype, "data", 2);
+__decorateClass$1([
+  state()
+], SmartAttributeCodeeditor.prototype, "isEditorLoaded", 2);
+SmartAttributeCodeeditor = __decorateClass$1([
+  customElement("smart-attribute-codeeditor")
+], SmartAttributeCodeeditor);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let SmartAttributeHandler = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.attributeScope = "style";
+    this.view = true;
+  }
+  codeChangeHandler(event) {
+    const {
+      detail: { value }
+    } = event;
+    this.dispatchEvent(new CustomEvent("code-change", { bubbles: true, composed: true, detail: { value } }));
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.smartValue = this.getAttributeValue();
+  }
+  getAttributeValue() {
+    let attributes = this.attributeScope && this.component ? this.component[this.attributeScope] : "";
+    let attributeValue;
+    if (this.attributeScope === "style") {
+      attributeValue = `"${attributes[this.attributeName]}"`;
+    } else {
+      attributeValue = this.attributeName ? attributes[this.attributeName] : "";
+    }
+    if (this.handlerScope && !this.component[this.handlerScope]) {
+      this.component[this.handlerScope] = {};
+    }
+    const smartAttributeValue = this.component && this.handlerScope && this.attributeName ? this.component[this.handlerScope][this.attributeName] : "";
+    return smartAttributeValue && smartAttributeValue !== "" ? smartAttributeValue : attributeValue;
+  }
+  render() {
+    return html`
+    ${this.component.errors && this.component.errors[this.attributeName] ? html`<div class="error-message-text">
+            ${this.component.errors[this.attributeName]}
+          </div>` : nothing}
+      ${this.view ? html`<smart-attribute-codeeditor
+              .containerStyle=${this.containerStyle ?? nothing}
+              .value=${this.attributeValue}
+              @change=${this.codeChangeHandler}
+            ></smart-attribute-codeeditor>` : nothing}`;
+  }
+  updated(_changedProperties) {
+    super.updated(_changedProperties);
+    if (_changedProperties.has("component") && this.component.uuid !== this.previousComponentId) {
+      this.previousComponentId = this.component.uuid;
+    }
+    this.smartValue = this.getAttributeValue();
+  }
+};
+SmartAttributeHandler.styles = [
+  css`
+      .error-message-text {
+        color: red;
+      }
+    `
+];
+__decorateClass([
+  property({ type: Object })
+], SmartAttributeHandler.prototype, "component", 2);
+__decorateClass([
+  property()
+], SmartAttributeHandler.prototype, "attributeName", 2);
+__decorateClass([
+  property()
+], SmartAttributeHandler.prototype, "attributeValue", 2);
+__decorateClass([
+  property({ type: Object })
+], SmartAttributeHandler.prototype, "containerStyle", 2);
+__decorateClass([
+  property()
+], SmartAttributeHandler.prototype, "attributeScope", 2);
+__decorateClass([
+  property()
+], SmartAttributeHandler.prototype, "handlerScope", 2);
+__decorateClass([
+  state()
+], SmartAttributeHandler.prototype, "smartValue", 2);
+__decorateClass([
+  state()
+], SmartAttributeHandler.prototype, "view", 2);
+__decorateClass([
+  state()
+], SmartAttributeHandler.prototype, "previousComponentId", 2);
+SmartAttributeHandler = __decorateClass([
+  customElement("smart-attribute-handler")
+], SmartAttributeHandler);
+
+export { SmartAttributeHandler };