xmlui 0.9.21 → 0.9.25

package/dist/language-server-web-worker.mjs

@@ -1,4 +1,4 @@
-import { m as main, s as start } from "./server-common-DW5h7Q34.mjs";
+import { m as main, s as start } from "./server-common-9TiLMTJj.mjs";
 var browser = main;
 const messageReader = new browser.BrowserMessageReader(self);
 messageReader.listen((message) => {

package/dist/language-server.mjs

@@ -1,4 +1,4 @@
-import { m as main, s as start$1 } from "./server-common-DW5h7Q34.mjs";
+import { m as main, s as start$1 } from "./server-common-9TiLMTJj.mjs";
 var node = main;
 function start() {
   const connection = node.createConnection(node.ProposedFeatures.all);

package/dist/lint-CYAUfk0_.mjs

@@ -0,0 +1,168 @@
+import { al as CORE_NAMESPACE_VALUE } from "./transform-DC0Gy6qw.mjs";
+const componentFileExtension = "xmlui";
+const codeBehindFileExtension = "xmlui.xs";
+const moduleFileExtension = "xs";
+var LintSeverity = /* @__PURE__ */ ((LintSeverity2) => {
+  LintSeverity2[LintSeverity2["Skip"] = 0] = "Skip";
+  LintSeverity2[LintSeverity2["Warning"] = 1] = "Warning";
+  LintSeverity2[LintSeverity2["Error"] = 2] = "Error";
+  return LintSeverity2;
+})(LintSeverity || {});
+var LintDiagKind = /* @__PURE__ */ ((LintDiagKind2) => {
+  LintDiagKind2[LintDiagKind2["UnrecognisedProp"] = 0] = "UnrecognisedProp";
+  return LintDiagKind2;
+})(LintDiagKind || {});
+function getLintSeverity(lintSeverityOption) {
+  if (!lintSeverityOption) {
+    return 1;
+  }
+  switch (lintSeverityOption.toLowerCase()) {
+    case "warning":
+      return 1;
+    case "error":
+      return 2;
+    case "skip":
+      return 0;
+    default:
+      console.warn(`Invalid lint severity option '${lintSeverityOption}'. Must be one of: 'warning', 'error', 'skip'. Defaulting to 'warning'.`);
+      return 1;
+  }
+}
+function lintApp({
+  appDef,
+  metadataProvider
+}) {
+  const entryPointLints = {
+    componentName: "Main",
+    lints: lint({
+      component: appDef.entryPoint,
+      metadataProvider
+    })
+  };
+  const compoundCompLints = (appDef.components ?? []).map((c) => {
+    const lints = lint({
+      component: c,
+      metadataProvider
+    });
+    return { lints, componentName: c.name };
+  });
+  return [entryPointLints, ...compoundCompLints].filter((diags) => diags.lints.length > 0);
+}
+function printComponentLints(lintDiags) {
+  console.group(`Validation on '${lintDiags.componentName}':`);
+  lintDiags.lints.forEach(({ message }) => {
+    console.warn(message);
+  });
+  console.groupEnd();
+}
+function lintErrorsComponent(lints) {
+  function makeComponent() {
+    const errList = lints.map((lint2, idx) => {
+      return {
+        type: "VStack",
+        props: { gap: "0px" },
+        children: [
+          {
+            type: "VStack",
+            props: { "backgroundColor": "lightgrey", padding: "10px" },
+            children: [
+              {
+                type: "H2",
+                props: {
+                  value: `#${idx + 1}: In component '${lint2.componentName}':`,
+                  color: "$color-info"
+                }
+              },
+              {
+                type: "VStack",
+                children: lint2.lints.map(({ message }, msgIdx) => {
+                  return {
+                    type: "Text",
+                    props: { value: `${idx + 1}.${msgIdx + 1}: ${message}`, fontWeight: "bold" }
+                  };
+                })
+              }
+            ]
+          }
+        ]
+      };
+    });
+    const comp = {
+      type: "VStack",
+      props: { padding: "$padding-normal", gap: 0 },
+      children: [
+        {
+          type: "H1",
+          props: {
+            value: `Errors found while checking Xmlui markup`,
+            padding: "$padding-normal",
+            backgroundColor: "$color-error",
+            color: "white"
+          }
+        },
+        {
+          type: "VStack",
+          props: {
+            gap: "$gap-tight",
+            padding: "$padding-normal"
+          },
+          children: errList
+        }
+      ]
+    };
+    return comp;
+  }
+  return makeComponent();
+}
+function lint({
+  component,
+  metadataProvider
+}) {
+  if ("component" in component) {
+    return lintHelp(component.component, metadataProvider, []);
+  }
+  return lintHelp(component, metadataProvider, []);
+}
+function lintHelp(component, metadataProvider, acc) {
+  const componentName = component.type.startsWith(CORE_NAMESPACE_VALUE) ? component.type.slice(CORE_NAMESPACE_VALUE.length + 1) : component.type;
+  const componentMdProvider = metadataProvider.getComponent(componentName);
+  if (componentMdProvider !== null && !componentMdProvider.allowArbitraryProps) {
+    lintAttrs(component, componentMdProvider, acc);
+  }
+  if (!component.children) {
+    return acc;
+  }
+  for (const child of component.children) {
+    lintHelp(child, metadataProvider, acc);
+  }
+  return acc;
+}
+function lintAttrs(component, metadataForCurrentComponent, diags) {
+  const invalidAttrNames = Object.keys(component.props ?? {}).filter((name) => !metadataForCurrentComponent.getAttr(name));
+  const invalidEvents = Object.keys(component.events ?? {}).filter((event) => !metadataForCurrentComponent.getEvent(event));
+  const invalidApis = Object.keys(component.api ?? {}).filter((api) => !metadataForCurrentComponent.getApi(api));
+  invalidAttrNames.push(...invalidEvents);
+  invalidAttrNames.push(...invalidApis);
+  for (const invalidAttrName of invalidAttrNames) {
+    diags.push(toUnrecognisedAttrDiag(component, invalidAttrName));
+  }
+}
+function toUnrecognisedAttrDiag(component, attr) {
+  return {
+    message: `Unrecognised property '${attr}' on component '${component.type}'.`,
+    kind: 0
+    /* UnrecognisedProp */
+  };
+}
+export {
+  LintSeverity as L,
+  codeBehindFileExtension as a,
+  lintErrorsComponent as b,
+  componentFileExtension as c,
+  LintDiagKind as d,
+  lint as e,
+  getLintSeverity as g,
+  lintApp as l,
+  moduleFileExtension as m,
+  printComponentLints as p
+};

package/dist/metadata-utils-CCIMqe69.mjs

@@ -0,0 +1,466 @@
+import { ak as onPrefixRegex, am as stripOnPrefix } from "./transform-DC0Gy6qw.mjs";
+const LinkTargetMd = [
+  {
+    value: "_self",
+    description: "The link will open in the same frame as it was clicked."
+  },
+  {
+    value: "_blank",
+    description: "The link will open in a new window or tab."
+  },
+  {
+    value: "_parent",
+    description: "The link will open in the parent frame. If no parent, behaves as _self."
+  },
+  {
+    value: "_top",
+    description: "The topmost browsing context. The link will open in the full body of the window. If no ancestors, behaves as _self."
+  },
+  {
+    value: "_unfencedTop",
+    description: "Allows embedded fenced frames to navigate the top-level frame, i.e. traversing beyond the root of the fenced frame."
+  }
+];
+const viewportSizeMd = [
+  {
+    value: "xs",
+    description: "Extra small devices (e.g., a small smartphone with low screen resolution)"
+  },
+  { value: "sm", description: "Small devices (e.g., a smartphone in landscape view)" },
+  { value: "md", description: "Medium devices (e.g., a tablet)" },
+  { value: "lg", description: "Large devices (e.g., a laptop)" },
+  { value: "xl", description: 'Extra large devices (e.g., a standard 20" monitor)' },
+  { value: "xxl", description: 'Extra extra large devices (e.g., a large 29" monitor)' }
+];
+const viewportSizeNames = Object.keys(viewportSizeMd);
+const sizeMd = [
+  { value: "xs", description: "Extra small button" },
+  { value: "sm", description: "Small button" },
+  { value: "md", description: "Medium button" },
+  { value: "lg", description: "Large button" }
+];
+const sizeValues = Object.keys(sizeMd);
+[...sizeValues];
+const buttonThemeValues = ["attention", "primary", "secondary"];
+const buttonThemeNames = [...buttonThemeValues];
+const buttonThemeMd = [
+  { value: "attention", description: "Attention state theme color" },
+  { value: "primary", description: "Primary theme color" },
+  { value: "secondary", description: "Secondary theme color" }
+];
+const buttonTypesMd = [
+  {
+    value: "button",
+    description: "Regular behavior that only executes logic if explicitly determined."
+  },
+  {
+    value: "submit",
+    description: "The button submits the form data to the server. This is the default for buttons in a Form or NativeForm component."
+  },
+  {
+    value: "reset",
+    description: "Resets all the controls to their initial values. Using it is ill advised for UX reasons."
+  }
+];
+const buttonVariantValues = ["solid", "outlined", "ghost"];
+const buttonVariantNames = [...buttonVariantValues];
+const buttonVariantMd = [
+  { value: "solid", description: "A button with a border and a filled background." },
+  {
+    value: "outlined",
+    description: "The button is displayed with a border and a transparent background."
+  },
+  {
+    value: "ghost",
+    description: "A button with no border and fill. Only the label is visible; the background is colored when hovered or clicked."
+  }
+];
+const alignmentOptionValues = ["start", "center", "end"];
+[...alignmentOptionValues];
+const alignmentOptionMd = [
+  { value: "center", description: "Place the content in the middle" },
+  {
+    value: "start",
+    description: "Justify the content to the left (to the right if in right-to-left)"
+  },
+  {
+    value: "end",
+    description: "Justify the content to the right (to the left if in right-to-left)"
+  }
+];
+const orientationOptionMd = [
+  { value: "horizontal", description: "The component will fill the available space horizontally" },
+  { value: "vertical", description: "The component will fill the available space vertically" }
+];
+const iconPositionValues = ["start", "end"];
+const iconPositionNames = [...iconPositionValues];
+const iconPositionMd = [
+  {
+    value: "start",
+    description: "The icon will appear at the start (left side when the left-to-right direction is set)"
+  },
+  {
+    value: "end",
+    description: "The icon will appear at the end (right side when the left-to-right direction is set)"
+  }
+];
+const labelPositionMd = [
+  {
+    value: "start",
+    description: "The left side of the input (left-to-right) or the right side of the input (right-to-left)"
+  },
+  {
+    value: "end",
+    description: "The right side of the input (left-to-right) or the left side of the input (right-to-left)"
+  },
+  { value: "top", description: "The top of the input" },
+  { value: "bottom", description: "The bottom of the input" }
+];
+const triggerPositionValues = ["start", "end"];
+const triggerPositionNames = [...triggerPositionValues];
+const validationStatusMd = [
+  // { value: "none", description: "No indicator" },
+  { value: "valid", description: "Visual indicator for an input that is accepted" },
+  { value: "warning", description: "Visual indicator for an input that produced a warning" },
+  { value: "error", description: "Visual indicator for an input that produced an error" }
+];
+const scrollAnchoringValues = ["top", "bottom"];
+[...scrollAnchoringValues];
+const TextVariantElement = {
+  abbr: "abbr",
+  cite: "cite",
+  code: "code",
+  codefence: "pre",
+  deleted: "del",
+  inserted: "ins",
+  keyboard: "kbd",
+  marked: "mark",
+  sample: "samp",
+  sub: "sub",
+  sup: "sup",
+  var: "var",
+  mono: "pre",
+  strong: "strong",
+  em: "em",
+  title: "span",
+  subtitle: "span",
+  small: "span",
+  caption: "span",
+  placeholder: "span",
+  paragraph: "p",
+  subheading: "h6",
+  tableheading: "h6",
+  secondary: "span"
+};
+const variantOptionsMd = [
+  { value: "abbr", description: "Represents an abbreviation or acronym" },
+  { value: "caption", description: "Represents the caption (or title) of a table" },
+  { value: "cite", description: "Is used to mark up the title of a cited work" },
+  { value: "code", description: "Represents a line of code" },
+  {
+    value: "codefence",
+    description: "Handles the display of code blocks if combined with a `code` variant"
+  },
+  { value: "deleted", description: "Represents text that has been deleted" },
+  { value: "em", description: "Marks text to stress emphasis" },
+  {
+    value: "inserted",
+    description: "Represents a range of text that has been added to a document"
+  },
+  {
+    value: "keyboard",
+    description: "Represents a span of text denoting textual user input from a keyboard or voice input"
+  },
+  {
+    value: "marked",
+    description: "Represents text which is marked or highlighted for reference or notation"
+  },
+  { value: "mono", description: "Text using a mono style font family" },
+  { value: "paragraph", description: "Represents a paragraph" },
+  {
+    value: "placeholder",
+    description: "Text that is mostly used as the placeholder style in input controls"
+  },
+  { value: "sample", description: "Represents sample (or quoted) output from a computer program" },
+  { value: "secondary", description: "Represents a bit dimmed secondary text" },
+  { value: "small", description: "Represents side-comments and small print" },
+  { value: "sub", description: "Specifies inline text as subscript" },
+  { value: "strong", description: "Contents have strong importance" },
+  { value: "subheading", description: "Indicates that the text is the subtitle in a heading" },
+  {
+    value: "subtitle",
+    description: "Indicates that the text is the subtitle of some other content"
+  },
+  { value: "sup", description: "Specifies inline text as superscript" },
+  { value: "tableheading", description: "Indicates that the text is a table heading" },
+  { value: "title", description: "Indicates that the text is the title of some other content" },
+  { value: "var", description: "Represents the name of a variable in a mathematical expression" }
+];
+const AbbreviationKeys = ["title"];
+const InsertedKeys = ["cite", "dateTime"];
+const VariantPropsKeys = [...AbbreviationKeys, ...InsertedKeys];
+const httpMethodNames = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace",
+  "connect"
+];
+const layoutOptionKeys = [
+  "horizontalAlignment",
+  "verticalAlignment",
+  "orientation",
+  "width",
+  "minWidth",
+  "maxWidth",
+  "height",
+  "minHeight",
+  "maxHeight",
+  "gap",
+  "border",
+  "borderTop",
+  "borderRight",
+  "borderBottom",
+  "borderLeft",
+  "borderColor",
+  "borderStyle",
+  "borderWidth",
+  "borderHorizontal",
+  "borderVertical",
+  "borderRadius",
+  "radiusTopLeft",
+  "radiusTopRight",
+  "radiusBottomLeft",
+  "radiusBottomRight",
+  "padding",
+  "paddingHorizontal",
+  "paddingVertical",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "backgroundColor",
+  "background",
+  "boxShadow",
+  "direction",
+  "overflowX",
+  "overflowY",
+  "zIndex",
+  "color",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "textDecoration",
+  "wrapContent",
+  "canShrink",
+  "margin",
+  "marginHorizontal",
+  "marginVertical",
+  "marginTop",
+  "marginRight",
+  "marginBottom",
+  "marginLeft",
+  "userSelect",
+  "letterSpacing",
+  "textTransform",
+  "lineHeight",
+  "opacity",
+  "cursor",
+  "textWrap",
+  "textAlign",
+  "textAlignLast",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "zoom",
+  "whiteSpace",
+  "textDecoration",
+  "textDecorationLine",
+  "textDecorationColor",
+  "textDecorationStyle",
+  "textDecorationThickness",
+  "textUnderlineOffset",
+  "outline",
+  "outlineWidth",
+  "outlineColor",
+  "outlineStyle",
+  "outlineOffset"
+];
+class MetadataProvider {
+  constructor(metadataCollection) {
+    this.metadataCollection = metadataCollection;
+  }
+  componentNames() {
+    return Object.keys(this.metadataCollection);
+  }
+  getComponent(componentName) {
+    const providerData = this.metadataCollection[componentName];
+    if (!providerData) {
+      return null;
+    }
+    return new ComponentMetadataProvider(providerData);
+  }
+}
+class ComponentMetadataProvider {
+  constructor(metadata) {
+    this.metadata = metadata;
+  }
+  /**
+   * Retrieves the metadata for a given property, explicit or implicit.
+   * @param name The name of the property.
+   * @returns The metadata for the property, or `undefined` if not found.
+   */
+  getProp(name) {
+    return this.metadata.props[name] ?? implicitPropsMetadata[name];
+  }
+  getAttr(name) {
+    var _a, _b, _c;
+    if (onPrefixRegex.test(name)) {
+      const eventName = stripOnPrefix(name);
+      const event = (_a = this.metadata.events) == null ? void 0 : _a[eventName];
+      if (event) {
+        return event;
+      }
+    }
+    const explicitProp = (_b = this.metadata.props) == null ? void 0 : _b[name];
+    if (explicitProp) {
+      return explicitProp;
+    }
+    const api = (_c = this.metadata.apis) == null ? void 0 : _c[name];
+    if (api) {
+      return api;
+    }
+    const layout = layoutMdForKey(name);
+    if (layout) {
+      return layout;
+    }
+    return implicitPropsMetadata[name];
+  }
+  getAttrForKind({ name, kind }) {
+    switch (kind) {
+      case "api":
+        return this.metadata.apis[name];
+      case "event":
+        return this.metadata.events[name];
+      case "prop":
+        return this.metadata.props[name];
+      case "implicit":
+        return implicitPropsMetadata[name];
+      case "layout":
+        return layoutMdForKey(name);
+    }
+  }
+  getAllAttributes() {
+    const attrNames = [];
+    for (const key of Object.keys(this.metadata.props ?? {})) {
+      attrNames.push({ name: key, kind: "prop" });
+    }
+    for (const key of Object.keys(this.metadata.events ?? {})) {
+      attrNames.push({ name: key, kind: "event" });
+    }
+    for (const key of Object.keys(this.metadata.apis ?? {})) {
+      attrNames.push({ name: key, kind: "api" });
+    }
+    for (const layoutKey of layoutOptionKeys) {
+      attrNames.push({ name: layoutKey, kind: "layout" });
+    }
+    for (const implicitPropKey of Object.keys(implicitPropsMetadata)) {
+      attrNames.push({ name: implicitPropKey, kind: "implicit" });
+    }
+    return attrNames;
+  }
+  getEvent(name) {
+    var _a;
+    return (_a = this.metadata.events) == null ? void 0 : _a[name];
+  }
+  getApi(name) {
+    var _a;
+    return (_a = this.metadata.apis) == null ? void 0 : _a[name];
+  }
+  get events() {
+    return this.metadata.events;
+  }
+  get apis() {
+    return this.metadata.apis;
+  }
+  get contextVars() {
+    return this.metadata.contextVars;
+  }
+  get allowArbitraryProps() {
+    return this.metadata.allowArbitraryProps;
+  }
+  get shortDescription() {
+    return this.metadata.shortDescription;
+  }
+  getMetadata() {
+    return this.metadata;
+  }
+}
+function layoutMdForKey(name) {
+  const metadata = {
+    description: "Layout property. Not yet documented"
+  };
+  if (layoutOptionKeys.includes(name)) {
+    return metadata;
+  }
+  for (const size of viewportSizeMd) {
+    const suffix = "-" + size.value;
+    if (name.endsWith(suffix)) {
+      const nameWithoutSize = name.slice(0, -suffix.length);
+      if (layoutOptionKeys.includes(nameWithoutSize)) {
+        return metadata;
+      }
+    }
+  }
+  return null;
+}
+const implicitPropsMetadata = {
+  inspect: {
+    description: "Determines whether the component can be inspected or not",
+    defaultValue: false,
+    valueType: "boolean"
+  },
+  data: {
+    description: "Specifies the data source for a component. Can be a URL string (fetched automatically), a DataSource or an expression to evaluate. Changes to this property trigger UI updates once data is loaded."
+  },
+  when: {
+    description: "Specifies a condition that must be met for the component to be displayed",
+    defaultValue: true,
+    valueType: "boolean"
+  }
+};
+function addOnPrefix(name) {
+  return "on" + name[0].toUpperCase() + name.substring(1);
+}
+export {
+  LinkTargetMd as L,
+  MetadataProvider as M,
+  TextVariantElement as T,
+  VariantPropsKeys as V,
+  alignmentOptionValues as a,
+  alignmentOptionMd as b,
+  buttonTypesMd as c,
+  buttonThemeMd as d,
+  buttonVariantMd as e,
+  variantOptionsMd as f,
+  scrollAnchoringValues as g,
+  buttonThemeNames as h,
+  iconPositionMd as i,
+  iconPositionNames as j,
+  buttonVariantNames as k,
+  labelPositionMd as l,
+  httpMethodNames as m,
+  layoutOptionKeys as n,
+  orientationOptionMd as o,
+  viewportSizeNames as p,
+  addOnPrefix as q,
+  sizeMd as s,
+  triggerPositionNames as t,
+  validationStatusMd as v
+};