xmlui 0.9.59 → 0.9.61

package/dist/lib/xmlui-parser.d.ts

@@ -241,94 +241,30 @@ declare type CollectedDeclarations = {
     moduleErrors?: ModuleErrors;
 };
 
-/**
- * This interface represents the properties of a component definition.
- */
 declare interface ComponentDef<TMd extends ComponentMetadata = ComponentMetadata> extends ComponentDefCore, Scriptable {
     props?: Record<keyof TMd["props"], any>;
     events?: Record<keyof TMd["events"], any>;
-    /**
-     * Components may have an API that other components can use to interact with them. This property holds
-     * the API methods associated with this component definition.
-     */
     api?: Record<keyof TMd["apis"], any>;
-    /**
-     * Components may provide context variables that can be used to in expressions and event handlers
-     * within the component.
-     * REVIEW: This property can be removed after migration to the new componend definition type.
-     */
     contextVars?: Record<keyof TMd["contextVars"], string>;
 }
 
-/**
- * This interface represents the core properties of a component definition (independent
- * of component metadata).
- */
 declare interface ComponentDefCore {
     type: string;
     uid?: string;
     testId?: string;
-    /**
-     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
-     * these are used later to resolve the `type` of the componentDef.
-     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
-     */
     namespaces?: Record<string, string>;
-    /**
-     * Though components manage their state internally, the app logic may require user state management.
-     * Components may have user *variables*, which the UI logic uses to manage the application state.
-     * This property holds the variables (name and value pairs) associated with this component definition.
-     */
     vars?: Record<string, any>;
-    /**
-     * Each component may have child components to constitute a hierarchy of components. This property
-     * holds the definition of these nested children.
-     */
     children?: ComponentDef[];
-    /**
-     * Components may have slots that can be filled with other components. This property holds the
-     * contents of the slots
-     */
     slots?: Record<string, ComponentDef[]>;
-    /**
-     * This property is evaluated to a Boolean value during run time. When this value is `true`, the
-     * component with its children chain is rendered; otherwise, the entire component hierarchy is omitted
-     * from the rendered tree.
-     */
     when?: string | boolean;
-    /**
-     * Some components work with data obtained asynchronously. Fetching this data requires some state
-     * management handling the complexity (including error handling) of data access. A *loader* is
-     * responsible for managing this logic. This property holds the loaders associated with this component
-     * definition.
-     */
     loaders?: ComponentDef[];
-    /**
-     * Components may have functions that are used to perform some logic. This property holds the functions
-     * (name and function body) associated with this component definition.
-     */
     functions?: Record<string, any>;
-    /**
-     * Components managing state through variables or loaders are wrapped with containers responsible
-     * for this job. Just as components, containers form a hierarchy. While working with this hierarchy,
-     * parent components may flow state values (key and value pairs) to their child containers. This
-     * property holds the name of state values to flow down to the direct child containers.
-     */
     uses?: string[];
-    /**
-     * Arbitrary debug information that can be attached to a component definition.
-     * Current usage:
-     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
-     *   belonging to the particular component definition.
-     */
     debug?: Record<string, any>;
 }
 
 export declare const componentFileExtension = "xmlui";
 
-/**
- * Sometimes, components and compound components can both be used
- */
 declare type ComponentLike = ComponentDef | CompoundComponentDef;
 
 export declare type ComponentLints = {
@@ -339,14 +275,6 @@ export declare type ComponentLints = {
     componentName: string;
 };
 
-/**
- * Components have metadata that the rendering engine uses to render the
- * component. This type defines the structure of such metadata.
- *
- * The type has generic parameters to ensure that type-checking works with
- * the metadata defined here in concert with the renderer object using the
- * same metadata type.
- */
 declare type ComponentMetadata<TProps extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TEvents extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TContextValues extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TApis extends Record<string, ComponentPropertyMetadata> = Record<string, any>> = {
     status?: "stable" | "experimental" | "deprecated" | "in progress";
     description?: string;
@@ -393,88 +321,24 @@ declare class ComponentMetadataProvider {
     getMetadata(): RestrictedComponentMetadata;
 }
 
-/**
- * Components have properties, events, context values, and exposed API
- * endpoints, each holding metadata the rendering engine uses at run time.
- * This type defines the structure of such metadata.
- */
 declare type ComponentPropertyMetadata = {
-    /**
-     * This field defines the description explaining the property. You can use
-     * markdown, as the UI may display this value.
-     */
     readonly description: string;
-    /**
-     * This field defines the type of the property. The rendering engine uses this
-     * information to validate the property value.
-     */
     readonly valueType?: PropertyValueType;
-    /**
-     * This field defines the available values of the property. The rendering engine
-     * uses this information to validate the property value.
-     */
     readonly availableValues?: readonly PropertyValueDescription[];
-    /**
-     * This field defines the default value of the property. The rendering engine uses
-     * this information to set the default value of the property.
-     */
     defaultValue?: any;
-    /**
-     * This field defines a validation function that the rendering engine uses to validate
-     * the property value. The function returns one or more hinst if the property value is
-     * invalid.
-     */
     isValid?: IsValidFunction<any>;
-    /**
-     * Indicates that a particular property is internal and should not be exposed in the
-     * documentation
-     */
     isInternal?: boolean;
-    /**
-     * Indicates that a particular property is required for the component to essentially function.
-     */
     isRequired?: boolean;
 };
 
 export declare const COMPOUND_COMP_ID = "Component";
 
-/**
- * XMLUI allows the creation of reusable components assembled from other XMLUI components (with markup).
- * This type represents such components. The name `CompoundComponent` refers to the assembled nature
- * of reusable components.
- */
 declare interface CompoundComponentDef extends Scriptable {
-    /**
-     * Each compound component must have a unique name. The markup uses this name to refer to the
-     * particular compound component.
-     */
     name: string;
-    /**
-     * Each compound component must have a single root component defining the component contents.
-     */
     component: ComponentDef;
-    /**
-     * Compound components may provide an API that other components can use to interact with them. This
-     * property holds the API methods associated with this compound component definition.
-     */
     api?: Record<string, any>;
-    /**
-     * This property holds the variables (name and value pairs) associated with this compound component
-     * definition.
-     */
     vars?: Record<string, any>;
-    /**
-     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
-     * these are used later to resolve the `type` of the componentDef.
-     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
-     */
     namespaces?: Record<string, string>;
-    /**
-     * Arbitrary debug information that can be attached to a component definition.
-     * Current usage:
-     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
-     *   belonging to the particular component definition.
-     */
     debug?: Record<string, any>;
     codeBehind?: string;
 }
@@ -735,36 +599,12 @@ export declare type FindTokenSuccess = {
     sharedParents: undefined;
 };
 
-/**
- * This type describes a font definition resource.
- */
 declare type FontDef = {
-    /**
-     * Specifies a name that will be used as the font face value for font properties
-     */
     fontFamily: string;
-    /**
-     * A fontStyle value. Accepts two values to specify a range that is supported by a font-face,
-     * for example `fontStyle: oblique 20deg 50deg`
-     */
     fontStyle?: string;
-    /**
-     * A font-weight value. Accepts two values to specify a range that is supported by a font-face,
-     * for example `font-weight: 100 900`
-     */
     fontWeight?: string;
-    /**
-     * This property determines how a font face is displayed based on whether and when it is downloaded
-     * and ready to use.
-     */
     fontDisplay?: string;
-    /**
-     * The mime type of the font file
-     */
     format?: string;
-    /**
-     * Specifies references to font resources.
-     */
     src: string;
 } | string;
 
@@ -1024,10 +864,6 @@ declare type PrefixOpSymbol = "++" | "--";
 
 export declare function printComponentLints(lintDiags: ComponentLints): void;
 
-/**
- * This type represents the description of a property value, which can be a string, a number,
- * or an object with a value and a description. This type is used in the metadata of a component.
- */
 declare type PropertyValueDescription = string | number | {
     value: string | number;
     description: string;
@@ -1089,21 +925,9 @@ declare interface ScripNodeBase {
     endToken?: ScriptingToken;
 }
 
-/**
- * This interface holds the properties representing a scriptable component definition.
- */
 declare interface Scriptable {
-    /**
-     * This property holds the text defined in all <script> sections attached to a component.
-     */
     script?: string;
-    /**
-     * This property holds the parsed form of scripts stored in code-behind files.
-     */
     scriptCollected?: CollectedDeclarations;
-    /**
-     * This property holds errors coming from parsing the code-behind scripts.
-     */
     scriptError?: any;
 }
 
@@ -1206,93 +1030,93 @@ export declare const enum SyntaxKind {
     ErrorNode = 27
 }
 
-declare const T_ARRAY_DESTRUCTURE = 202;
+declare const T_ARRAY_DESTRUCTURE: number;
 
-declare const T_ARRAY_LITERAL = 110;
+declare const T_ARRAY_LITERAL: number;
 
-declare const T_ARROW_EXPRESSION = 115;
+declare const T_ARROW_EXPRESSION: number;
 
-declare const T_ARROW_EXPRESSION_STATEMENT = 4;
+declare const T_ARROW_EXPRESSION_STATEMENT: number;
 
-declare const T_ASSIGNMENT_EXPRESSION = 113;
+declare const T_ASSIGNMENT_EXPRESSION: number;
 
-declare const T_BINARY_EXPRESSION = 101;
+declare const T_BINARY_EXPRESSION: number;
 
-declare const T_BLOCK_STATEMENT = 1;
+declare const T_BLOCK_STATEMENT: number;
 
-declare const T_BREAK_STATEMENT = 10;
+declare const T_BREAK_STATEMENT: number;
 
-declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION = 106;
+declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION: number;
 
-declare const T_CONDITIONAL_EXPRESSION = 103;
+declare const T_CONDITIONAL_EXPRESSION: number;
 
-declare const T_CONST_STATEMENT = 6;
+declare const T_CONST_STATEMENT: number;
 
-declare const T_CONTINUE_STATEMENT = 11;
+declare const T_CONTINUE_STATEMENT: number;
 
-declare const T_DESTRUCTURE = 201;
+declare const T_DESTRUCTURE: number;
 
-declare const T_DO_WHILE_STATEMENT = 13;
+declare const T_DO_WHILE_STATEMENT: number;
 
-declare const T_EMPTY_STATEMENT = 2;
+declare const T_EMPTY_STATEMENT: number;
 
-declare const T_EXPRESSION_STATEMENT = 3;
+declare const T_EXPRESSION_STATEMENT: number;
 
-declare const T_FOR_IN_STATEMENT = 15;
+declare const T_FOR_IN_STATEMENT: number;
 
-declare const T_FOR_OF_STATEMENT = 16;
+declare const T_FOR_OF_STATEMENT: number;
 
-declare const T_FOR_STATEMENT = 14;
+declare const T_FOR_STATEMENT: number;
 
-declare const T_FUNCTION_DECLARATION = 20;
+declare const T_FUNCTION_DECLARATION: number;
 
-declare const T_FUNCTION_INVOCATION_EXPRESSION = 104;
+declare const T_FUNCTION_INVOCATION_EXPRESSION: number;
 
-declare const T_IDENTIFIER = 107;
+declare const T_IDENTIFIER: number;
 
-declare const T_IF_STATEMENT = 8;
+declare const T_IF_STATEMENT: number;
 
-declare const T_LET_STATEMENT = 5;
+declare const T_LET_STATEMENT: number;
 
-declare const T_LITERAL = 109;
+declare const T_LITERAL: number;
 
-declare const T_MEMBER_ACCESS_EXPRESSION = 105;
+declare const T_MEMBER_ACCESS_EXPRESSION: number;
 
-declare const T_NO_ARG_EXPRESSION = 114;
+declare const T_NO_ARG_EXPRESSION: number;
 
-declare const T_OBJECT_DESTRUCTURE = 203;
+declare const T_OBJECT_DESTRUCTURE: number;
 
-declare const T_OBJECT_LITERAL = 111;
+declare const T_OBJECT_LITERAL: number;
 
-declare const T_POSTFIX_OP_EXPRESSION = 117;
+declare const T_POSTFIX_OP_EXPRESSION: number;
 
-declare const T_PREFIX_OP_EXPRESSION = 116;
+declare const T_PREFIX_OP_EXPRESSION: number;
 
-declare const T_REACTIVE_VAR_DECLARATION = 118;
+declare const T_REACTIVE_VAR_DECLARATION: number;
 
-declare const T_RETURN_STATEMENT = 9;
+declare const T_RETURN_STATEMENT: number;
 
-declare const T_SEQUENCE_EXPRESSION = 102;
+declare const T_SEQUENCE_EXPRESSION: number;
 
-declare const T_SPREAD_EXPRESSION = 112;
+declare const T_SPREAD_EXPRESSION: number;
 
-declare const T_SWITCH_CASE = 204;
+declare const T_SWITCH_CASE: number;
 
-declare const T_SWITCH_STATEMENT = 19;
+declare const T_SWITCH_STATEMENT: number;
 
-declare const T_TEMPLATE_LITERAL_EXPRESSION = 108;
+declare const T_TEMPLATE_LITERAL_EXPRESSION: number;
 
-declare const T_THROW_STATEMENT = 17;
+declare const T_THROW_STATEMENT: number;
 
-declare const T_TRY_STATEMENT = 18;
+declare const T_TRY_STATEMENT: number;
 
-declare const T_UNARY_EXPRESSION = 100;
+declare const T_UNARY_EXPRESSION: number;
 
-declare const T_VAR_DECLARATION = 200;
+declare const T_VAR_DECLARATION: number;
 
-declare const T_VAR_STATEMENT = 7;
+declare const T_VAR_STATEMENT: number;
 
-declare const T_WHILE_STATEMENT = 12;
+declare const T_WHILE_STATEMENT: number;
 
 declare type TableDescriptor = {
     name: string;
@@ -1319,28 +1143,10 @@ declare interface TemplateLiteralExpression extends ExpressionBase {
     segments: (Literal | Expression)[];
 }
 
-/**
- * This type represents a theme definition object. Theme files can use this object's JSON-serialized
- * format to define an app theme; an app can have multiple theme files.
- */
 declare interface ThemeDefinition extends ThemeDefinitionDetails {
-    /**
-     * Theme id
-     */
     id: string;
-    /**
-     * Optional theme name
-     */
     name?: string;
-    /**
-     * A theme can extend existing themes. The extension means that the theme variable values defined
-     * in the new theme override the base theme's variable values.
-     */
     extends?: string | Array<string>;
-    /**
-     * This property defines the tone-dependent theme variable values. When a theme variable value is
-     * resolved, the common theme variable values are overridden with their theme-specific values.
-     */
     tones?: Record<string | ThemeTone, ThemeDefinitionDetails>;
 }
 
@@ -1349,15 +1155,7 @@ declare interface ThemeDefinitionDetails {
     resources?: Record<string, string | FontDef>;
 }
 
-/**
- * This type describes one the available theme tones.
- */
-declare type ThemeTone = (typeof ThemeToneKeys)[number];
-
-/**
- * Each theme can have a light or a dark tone.
- */
-declare const ThemeToneKeys: readonly ["light", "dark"];
+declare type ThemeTone = "light" | "dark";
 
 declare type THROW_STATEMENT = typeof T_THROW_STATEMENT;
 

package/dist/lib/xmlui-parser.mjs

@@ -1,5 +1,5 @@
-import { q as s, s as t, A as i, t as r, v as n, C as o, r as d, a as g, b as m, f as C, e as p, g as l, c as N, D as _, o as D, E as c, N as E, P as S, S as x, T as U, U as A, j as L, h as P, d as f, i as y, B as u, n as b, k as h, m as M, l as v, w as I, u as O, p as T, x as K, z as R, y as X } from "./transform-BboeJCuA.mjs";
-import { b as F, L as B, X as j, a as q, c as w, g as z, e as G, l as H, d as V, m as W, p as J } from "./xmlui-serializer-D0p6Hyum.mjs";
+import { q as s, s as t, A as i, t as r, v as n, C as o, r as d, a as g, b as m, f as C, e as p, g as l, c as N, D as _, o as D, E as c, N as E, P as S, S as x, T as U, U as A, j as L, h as P, d as f, i as y, B as u, n as b, k as h, m as M, l as v, w as I, u as O, p as T, x as K, z as R, y as X } from "./transform-BdB0APqE.mjs";
+import { b as F, L as B, X as j, a as q, c as w, g as z, e as G, l as H, d as V, m as W, p as J } from "./xmlui-serializer-COAfRndx.mjs";
 export {
   s as AttributeKeyNode,
   t as AttributeListNode,

package/dist/lib/{xmlui-serializer-D0p6Hyum.mjs → xmlui-serializer-COAfRndx.mjs}

@@ -1,4 +1,4 @@
-import { v as A, t as j } from "./transform-BboeJCuA.mjs";
+import { v as A, t as j } from "./transform-BdB0APqE.mjs";
 const k = "xmlui", P = "xmlui.xs", D = "xs";
 var V = /* @__PURE__ */ ((l) => (l[l.Skip = 0] = "Skip", l[l.Warning = 1] = "Warning", l[l.Error = 2] = "Error", l))(V || {}), w = /* @__PURE__ */ ((l) => (l[l.UnrecognisedProp = 0] = "UnrecognisedProp", l))(w || {});
 function L(l) {