xmlui 0.9.21 → 0.9.25

package/dist/scripts/src/components-core/utils/hooks.js

@@ -322,3 +322,29 @@ const useRealBackground = (element) => {
     return (0, react_1.useMemo)(() => element ? realBackgroundColor(element) : 'transparent', [element, counter]);
 };
 exports.useRealBackground = useRealBackground;
+// export const useIsInViewport = (ref, observerOptions) => {
+//   const [entered, setEntered] = useState(false);
+//   const observer = useRef(
+//     new IntersectionObserver(
+//       ([entry]) => setEntered(entry.isIntersecting),
+//       observerOptions
+//     )
+//   );
+//
+//   useEffect(() => {
+//     const element = ref.current;
+//     const ob = observer.current;
+//
+//     // stop observing once the element has entered the viewport for the first time.
+//     // if (entered) {
+//     //   ob.disconnect();
+//     //   return;
+//     // }
+//
+//     if (element) ob.observe(element);
+//
+//     return () => ob.disconnect();
+//   }, [entered, ref]);
+//
+//   return entered;
+// };

package/dist/scripts/src/components-core/utils/misc.js

@@ -126,7 +126,7 @@ const useEvent = (callback) => {
     }, [callback]);
     return (0, react_1.useCallback)((...args) => {
         const latestFn = callbackRef.current;
-        return latestFn(...args);
+        return latestFn === null || latestFn === void 0 ? void 0 : latestFn(...args);
     }, [callbackRef]);
 };
 exports.useEvent = useEvent;

package/dist/scripts/src/components-core/utils/request-params.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRequestParamPart = convertRequestParamPart;
+// Testable helper function to convert request parameters
+function convertRequestParamPart(part, paramTypes) {
+    if (!paramTypes)
+        return part;
+    const result = Object.assign({}, part);
+    Object.keys(part).forEach((key) => {
+        if (!(key in paramTypes))
+            return;
+        const partValue = part[key];
+        const partValueType = typeof partValue;
+        switch (paramTypes[key]) {
+            // --- Parameter to integer
+            case "integer":
+                switch (partValueType) {
+                    case "number":
+                        result[key] = Math.round(partValue);
+                        break;
+                    case "string":
+                        result[key] = parseInt(partValue, 10);
+                        break;
+                    case "boolean":
+                        result[key] = partValue ? 1 : 0;
+                        break;
+                }
+                break;
+            // --- Parameter to float
+            case "float":
+            case "real":
+            case "double":
+                switch (partValueType) {
+                    case "number":
+                        result[key] = partValue;
+                        break;
+                    case "string":
+                        result[key] = parseFloat(partValue);
+                        break;
+                    case "boolean":
+                        result[key] = partValue ? 1 : 0;
+                        break;
+                }
+                break;
+            // --- Parameter to boolean
+            case "boolean":
+                switch (partValueType) {
+                    case "string":
+                        switch (partValue.toLowerCase()) {
+                            case "true":
+                            case "yes":
+                            case "on":
+                                result[key] = true;
+                                break;
+                            case "false":
+                            case "no":
+                            case "off":
+                                result[key] = false;
+                                break;
+                        }
+                        break;
+                    case "number":
+                        result[key] = !!partValue;
+                        break;
+                }
+                break;
+        }
+    });
+    return result;
+}

package/dist/scripts/src/logging/LoggerContext.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogger = exports.LoggerProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const LogContext = (0, react_1.createContext)(undefined);
+const LoggerProvider = ({ children }) => {
+    const [logs, setLogs] = (0, react_1.useState)([]);
+    const addLog = (0, react_1.useCallback)((args) => {
+        const newEntry = { timestamp: new Date(), args };
+        setLogs(prev => [...prev, newEntry]);
+    }, []);
+    return ((0, jsx_runtime_1.jsx)(LogContext.Provider, { value: { logs, addLog }, children: children }));
+};
+exports.LoggerProvider = LoggerProvider;
+const useLogger = () => {
+    const context = (0, react_1.useContext)(LogContext);
+    if (!context)
+        throw new Error('useLogger must be used within LoggerProvider');
+    return context;
+};
+exports.useLogger = useLogger;

package/dist/scripts/src/logging/LoggerInitializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerInitializer = void 0;
+const LoggerContext_1 = require("./LoggerContext");
+const react_1 = require("react");
+const LoggerService_1 = require("./LoggerService");
+const LoggerInitializer = () => {
+    const { addLog } = (0, LoggerContext_1.useLogger)();
+    (0, react_1.useEffect)(() => {
+        LoggerService_1.loggerService.registerCallback(addLog);
+    }, [addLog]);
+    return null;
+};
+exports.LoggerInitializer = LoggerInitializer;

package/dist/scripts/src/logging/LoggerService.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerService = void 0;
+class LoggerService {
+    constructor() {
+        this.isDev = process.env.NODE_ENV === "development" || !!process.env.VITE_DEV_MODE;
+    }
+    static getInstance() {
+        if (!LoggerService.instance) {
+            LoggerService.instance = new LoggerService();
+        }
+        return LoggerService.instance;
+    }
+    registerCallback(callback) {
+        if (this.isDev) {
+            this.callback = callback;
+        }
+    }
+    log(args) {
+        if (!this.isDev)
+            return;
+        console.log("[xmlui.log]", ...args);
+        if (this.callback) {
+            this.callback(args);
+        }
+    }
+    warn(args) {
+        if (!this.isDev)
+            return;
+        console.warn("[xmlui.warn]", ...args);
+        if (this.callback) {
+            this.callback(args);
+        }
+    }
+    info(args) {
+        if (!this.isDev)
+            return;
+        console.info("[xmlui.info]", ...args);
+        if (this.callback) {
+            this.callback(args);
+        }
+    }
+    error(args) {
+        if (!this.isDev)
+            return;
+        console.error("[xmlui.error]", ...args);
+        if (this.callback) {
+            this.callback(args);
+        }
+    }
+    trace(args) {
+        if (!this.isDev)
+            return;
+        console.trace("[xmlui.trace]", ...args);
+        if (this.callback) {
+            this.callback(args);
+        }
+    }
+}
+exports.loggerService = LoggerService.getInstance();

package/dist/scripts/src/parsers/xmlui-parser/transform.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CORE_NAMESPACE_VALUE = exports.onPrefixRegex = exports.UCRegex = exports.COMPOUND_COMP_ID = void 0;
 exports.nodeToComponentDef = nodeToComponentDef;
+exports.stripOnPrefix = stripOnPrefix;
 const code_behind_collect_1 = require("../scripting/code-behind-collect");
 const syntax_kind_1 = require("./syntax-kind");
 const ParserError_1 = require("./ParserError");
@@ -1103,3 +1104,9 @@ function getNamespaceResolvedComponentName(node, getText, namespaceStack) {
     }
     return resolvedNamespace + "." + name;
 }
+/**
+* @param name - The name of the event in camelCase, with "on" prefix.
+*/
+function stripOnPrefix(name) {
+    return name[2].toLowerCase() + name.substring(3);
+}

package/dist/{server-common-DW5h7Q34.mjs → server-common-9TiLMTJj.mjs}

@@ -1,6 +1,7 @@
 import { MarkupKind as MarkupKind$1, CompletionItemKind as CompletionItemKind$1, TextDocuments as TextDocuments$1, TextDocumentSyncKind, DidChangeConfigurationNotification } from "vscode-languageserver";
 import { TextDocument as TextDocument$1 } from "vscode-languageserver-textdocument";
-import { S as SyntaxKind, x as findTokenAtPos, c as createXmlUiParser } from "./parser-CBXS8ft2.mjs";
+import { S as SyntaxKind, ap as findTokenAtPos, N as createXmlUiParser } from "./transform-DC0Gy6qw.mjs";
+import { q as addOnPrefix, M as MetadataProvider } from "./metadata-utils-CCIMqe69.mjs";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getAugmentedNamespace(n) {
   if (n.__esModule) return n;
@@ -18695,7 +18696,7 @@ function generateCompNameDescription(componentName, metadata) {
   if (metadata.props && Object.keys(metadata.props).length > 0) {
     sections.push("\n## Properties");
     Object.entries(metadata.props).filter(([_, prop]) => !prop.isInternal).forEach(([propName, prop]) => {
-      sections.push(generatePropDescription(propName, prop));
+      sections.push(generateAttrDescription(propName, prop));
     });
   }
   if (metadata.events && Object.keys(metadata.events).length > 0) {
@@ -18721,21 +18722,27 @@ ${contextVar.description}`);
   }
   return sections.join("\n\n");
 }
-function generatePropDescription(propName, prop) {
-  let propText = `### \`${propName}\`
-${prop.description}`;
-  if (prop.defaultValue !== void 0) {
+function generateAttrDescription(attrName, attrMd) {
+  let propText = `\`${attrName}\``;
+  if (attrMd.isRequired) {
+    propText += " (required)";
+  }
+  propText += ": ";
+  if (attrMd.description) {
+    propText += attrMd.description;
+  }
+  if (attrMd.defaultValue !== void 0) {
     propText += `
 
-Default: \`${prop.defaultValue}\``;
+Default: \`${attrMd.defaultValue}\``;
   }
-  if (prop.availableValues) {
-    const values = prop.availableValues.map(
+  if (attrMd.availableValues && attrMd.availableValues.length > 0) {
+    const values = attrMd.availableValues.map(
       (v) => typeof v === "object" ? `- \`${v.value}\`: ${v.description}` : `- \`${v}\``
     ).join("\n");
     propText += `
 
-Allowed values:
+**Allowed values**:
 ${values}`;
   }
   return propText;
@@ -18798,15 +18805,17 @@ function handleCompletionResolve({
   var _a2;
   const metadataAccessInfo = (_a2 = item == null ? void 0 : item.data) == null ? void 0 : _a2.metadataAccessInfo;
   if (metadataAccessInfo) {
-    const { componentName } = metadataAccessInfo;
-    const componentMeta = metaByComp2[componentName];
-    if ("prop" in metadataAccessInfo) {
-      const propName = metadataAccessInfo.prop;
-      const propMeta = componentMeta.props[propName];
-      item.documentation = markupContent(generatePropDescription(propName, propMeta));
+    const { componentName, attribute } = metadataAccessInfo;
+    const componentMeta = metaByComp2.getComponent(componentName);
+    if (!componentMeta) {
+      return null;
+    }
+    if (attribute) {
+      const attributeMetadata = componentMeta.getAttrForKind(attribute);
+      item.documentation = markupContent(generateAttrDescription(attribute.name, attributeMetadata));
     } else {
       item.documentation = markupContent(
-        generateCompNameDescription(componentName, componentMeta)
+        generateCompNameDescription(componentName, componentMeta.getMetadata())
       );
     }
   }
@@ -18846,12 +18855,12 @@ function handleCompletion({ parseResult: { node }, getText, metaByComp: metaByCo
   if (completeForProp) {
     const tagNameNode = findTagNameNodeInStack(chainAtPos);
     const compName = compNameForTagNameNode(tagNameNode, getText);
-    return completionForNewProp(compName, metaByComp2);
+    return completionForNewAttr(compName, metaByComp2);
   }
   return null;
 }
 function allComponentNames(md) {
-  return Object.keys(md).map((compName) => CompletionItemBuilder.withComponent(compName).componentResolveData().build());
+  return md.componentNames().map(componentCompletionItem);
 }
 function matchingTagName(elementNode, metaByComp2, getText) {
   const nameNode = elementNode.children.find((c) => c.kind === SyntaxKind.TagNameNode);
@@ -18875,7 +18884,7 @@ function matchingTagName(elementNode, metaByComp2, getText) {
   }
   name = getText(nameIdent);
   const value = nameSpace !== void 0 ? nameSpace + ":" + name : name;
-  return [CompletionItemBuilder.withComponent(value).build()];
+  return [componentCompletionItem(value)];
 }
 function handleCompletionInsideToken(chainAtPos, position, metaByComp2, getText) {
   const parent = chainAtPos.at(-2);
@@ -18898,81 +18907,75 @@ function handleCompletionInsideToken(chainAtPos, position, metaByComp2, getText)
     case SyntaxKind.AttributeKeyNode: {
       const tagNameNode = findTagNameNodeInStack(chainAtPos);
       const compName = compNameForTagNameNode(tagNameNode, getText);
-      return completionForNewProp(compName, metaByComp2);
+      return completionForNewAttr(compName, metaByComp2);
     }
   }
   return null;
 }
-function completionForNewProp(compName, metaByComp2) {
-  const metadata = metaByComp2[compName];
-  if (!metadata || !metadata.props) {
+function completionForNewAttr(compName, metaByComp2) {
+  const metadata = metaByComp2.getComponent(compName);
+  if (!metadata) {
     return null;
   }
-  return Object.keys(metadata.props).map(
-    (propName) => CompletionItemBuilder.withProp(propName).propResolveData(compName).build()
-  );
+  const completionItemFromAttr = attributeCompletionItem.bind({}, compName);
+  return metadata.getAllAttributes().map(completionItemFromAttr);
 }
-function markupContent(content) {
+function attrKindToCompletionItemKind(attrKind) {
+  switch (attrKind) {
+    case "api":
+      return CompletionItemKind$1.Function;
+    case "event":
+      return CompletionItemKind$1.Event;
+    case "implicit":
+    case "layout":
+    case "prop":
+      return CompletionItemKind$1.Property;
+  }
+}
+function attributeCompletionItem(componentName, attribute) {
+  const label = attribute.kind === "event" ? addOnPrefix(attribute.name) : attribute.name;
   return {
-    kind: MarkupKind$1.Markdown,
-    value: content
+    label,
+    kind: attrKindToCompletionItemKind(attribute.kind),
+    data: {
+      metadataAccessInfo: {
+        componentName,
+        attribute
+      }
+    }
   };
 }
-class CompletionItemBuilder {
-  static withComponent(name) {
-    const item = {
-      label: name,
-      kind: CompletionItemKind$1.Constructor
-    };
-    return new CompletionItemBuilder(item);
-  }
-  static withProp(propName) {
-    const item = {
-      label: propName,
-      kind: CompletionItemKind$1.Property
-    };
-    return new CompletionItemBuilder(item);
-  }
-  constructor(item) {
-    this.item = item;
-  }
-  componentResolveData() {
-    const data = {
-      metadataAccessInfo: { componentName: this.item.label }
-    };
-    this.item.data = data;
-    return this;
-  }
-  propResolveData(componentName) {
-    const data = {
+function componentCompletionItem(componentName) {
+  return {
+    label: componentName,
+    kind: CompletionItemKind$1.Constructor,
+    data: {
       metadataAccessInfo: {
-        componentName,
-        prop: this.item.label
+        componentName
       }
-    };
-    this.item.data = data;
-    return this;
-  }
-  build() {
-    return this.item;
-  }
+    }
+  };
+}
+function markupContent(content) {
+  return {
+    kind: MarkupKind$1.Markdown,
+    value: content
+  };
 }
-function handleHover({ parseResult: { node }, getText, metaByComp: metaByComp2 }, position) {
+function handleHoverCore({ node, getText, metaByComp: metaByComp2 }, position) {
   const findRes = findTokenAtPos(node, position);
-  console.log("findres: ", findRes);
   if (findRes === void 0) {
     return null;
   }
   const { chainAtPos } = findRes;
   const atNode = chainAtPos.at(-1);
   const parentNode = chainAtPos.at(-2);
-  console.log("hovering: ", atNode, parentNode);
   switch (atNode.kind) {
     case SyntaxKind.Identifier:
       switch (parentNode == null ? void 0 : parentNode.kind) {
         case SyntaxKind.TagNameNode: {
           return hoverName({
-            collectedComponentMetadata: metaByComp2,
+            metaByComp: metaByComp2,
             tagNameNode: parentNode,
             identNode: atNode,
             getText
@@ -18991,13 +18994,30 @@ function handleHover({ parseResult: { node }, getText, metaByComp: metaByComp2 }
   }
   return null;
 }
+function handleHover(ctx, position) {
+  const hoverRes = handleHoverCore(ctx, position);
+  if (hoverRes === null) {
+    return null;
+  }
+  const { value, range } = hoverRes;
+  return {
+    contents: {
+      kind: MarkupKind$1.Markdown,
+      value
+    },
+    range: {
+      start: ctx.offsetToPosition(range.pos),
+      end: ctx.offsetToPosition(range.end)
+    }
+  };
+}
 function hoverAttr({
   metaByComp: metaByComp2,
   attrKeyNode,
   parentStack,
   getText
 }) {
-  var _a2, _b, _c;
+  var _a2, _b;
   if (parentStack.at(-1).kind !== SyntaxKind.AttributeNode) {
     return null;
   }
@@ -19013,7 +19033,7 @@ function hoverAttr({
     return null;
   }
   const compName = compNameForTagNameNode(tagNameNode, getText);
-  const component = metaByComp2[compName];
+  const component = metaByComp2.getComponent(compName);
   if (!component) {
     return null;
   }
@@ -19022,7 +19042,6 @@ function hoverAttr({
   if (identIdx === -1) {
     return null;
   }
-  console.log("here");
   const attrIdent = attrKeyChildren[identIdx];
   const propIsNamespaceDefinition = ((_a2 = attrKeyChildren[identIdx + 1]) == null ? void 0 : _a2.kind) === SyntaxKind.Colon && ((_b = attrKeyChildren[identIdx + 2]) == null ? void 0 : _b.kind) === SyntaxKind.Identifier && getText(attrIdent) === "xmlns";
   if (propIsNamespaceDefinition) {
@@ -19034,12 +19053,12 @@ function hoverAttr({
       }
     };
   }
-  const propName = getText(attrIdent);
-  const propMetadata = (_c = component.props) == null ? void 0 : _c[propName];
-  if (!propMetadata) {
+  const attrName = getText(attrIdent);
+  const attrMd = component.getAttr(attrName);
+  if (!attrMd) {
     return null;
   }
-  const value = generatePropDescription(propName, propMetadata);
+  const value = generateAttrDescription(attrName, attrMd);
   return {
     value,
     range: {
@@ -19049,16 +19068,17 @@ function hoverAttr({
   };
 }
 function hoverName({
-  collectedComponentMetadata: collectedComponentMetadata2,
+  metaByComp: metaByComp2,
   tagNameNode,
   identNode,
   getText
 }) {
+  var _a2;
   const compName = compNameForTagNameNode(tagNameNode, getText);
   if (!compName) {
     return null;
   }
-  const compMetadata = collectedComponentMetadata2[compName];
+  const compMetadata = (_a2 = metaByComp2.getComponent(compName)) == null ? void 0 : _a2.getMetadata();
   if (!compMetadata) {
     return null;
   }
@@ -19072,6 +19092,7 @@ function hoverName({
   };
 }
 const metaByComp = collectedComponentMetadata;
+const metadataProvider = new MetadataProvider(metaByComp);
 function start(connection2) {
   const documents = new TextDocuments$1(TextDocument$1);
   let hasConfigurationCapability = false;
@@ -19119,10 +19140,10 @@ function start(connection2) {
       return [];
     }
     const parseResult = parseDocument(document);
-    return handleCompletion({ parseResult: parseResult.parseResult, getText: parseResult.getText, metaByComp }, document.offsetAt(position));
+    return handleCompletion({ parseResult: parseResult.parseResult, getText: parseResult.getText, metaByComp: metadataProvider }, document.offsetAt(position));
   });
   connection2.onCompletionResolve((completionItem) => {
-    return handleCompletionResolve({ metaByComp, item: completionItem });
+    return handleCompletionResolve({ metaByComp: metadataProvider, item: completionItem });
   });
   connection2.onHover(({ position, textDocument }) => {
     connection2.console.log(`Received request hover`);
@@ -19132,25 +19153,12 @@ function start(connection2) {
     }
     const { parseResult, getText } = parseDocument(document);
     const ctx = {
-      parseResult,
+      node: parseResult.node,
       getText,
-      metaByComp
-    };
-    const hoverRes = handleHover(ctx, document.offsetAt(position));
-    if (hoverRes === null) {
-      return null;
-    }
-    const { value, range } = hoverRes;
-    return {
-      contents: {
-        kind: MarkupKind$1.Markdown,
-        value
-      },
-      range: {
-        start: document.positionAt(range.pos),
-        end: document.positionAt(range.end)
-      }
+      metaByComp: metadataProvider,
+      offsetToPosition: document.positionAt
     };
+    return handleHover(ctx, document.offsetAt(position));
   });
   const parsedDocuments = /* @__PURE__ */ new Map();
   function parseDocument(document) {