xmlui 0.11.4 → 0.11.6

package/dist/scripts/src/components-core/markup-check.js

@@ -1,279 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkXmlUiMarkup = checkXmlUiMarkup;
-exports.visitComponent = visitComponent;
-const ParameterParser_1 = require("./script-runner/ParameterParser");
-const Parser_1 = require("../parsers/scripting/Parser");
-const descriptorHelper_1 = require("./descriptorHelper");
-const abstractions_1 = require("../components/abstractions");
-/**
- * This function checks the XMLUI markup for potential issues. It retrieves
- * a list of errors and warnings.
- * @param rootDef Root component definition
- * @param components Components referenced in the XMLUI markup
- * @param devMode Indicates if the check is performed in development mode
- * @returns List of errors and warnings
- */
-function checkXmlUiMarkup(rootDef, components, metadataHandler, devMode) {
-    const errorsCollected = [];
-    // --- Initialize the check
-    const continuation = {};
-    const componentIdsCollected = new Set();
-    const compoundIdsCollected = new Set();
-    // --- Visit the root component
-    if (rootDef) {
-        visitComponent(rootDef, null, componentDefVisitor, continuation, metadataHandler);
-    }
-    // --- Visit the compound components
-    if (!continuation.abort) {
-        for (const component of components) {
-            // --- Rule: Compound component name must be a valid JavaScript identifier
-            if (!isValidIdentifier(component.name)) {
-                reportError("M007", "Component", component.name);
-            }
-            // --- Rule: Compound component name cannot be 'Component'
-            if (component.name === "Component") {
-                reportError("M008", "Component", component.name);
-            }
-            // --- Rule: Compound component must not have the name of a registered component
-            if (metadataHandler.componentRegistered(component.name)) {
-                reportError("M009", "Component", component.name);
-            }
-            // --- Rule: Compound component name must be unique
-            if (compoundIdsCollected.has(component.name)) {
-                reportError("M010", "Component", component.name);
-            }
-            else {
-                compoundIdsCollected.add(component.name);
-            }
-            // --- Reset component ID scope
-            componentIdsCollected.clear();
-            // --- Visit the compount component's definition
-            visitComponent(component.component, null, componentDefVisitor, continuation, metadataHandler);
-        }
-    }
-    // --- Done.
-    return errorsCollected;
-    // --- This visitor checks the rules for a particular component
-    function componentDefVisitor(def, parent, before, continuation) {
-        var _a, _b, _c, _d, _e;
-        // --- This is the visitor function to check a ComponentDef markup
-        if (!before) {
-            // --- Do not visit the component definition after its children have been visited
-            return;
-        }
-        // --- Rule: Component name must be registered
-        if (!metadataHandler.componentRegistered(def.type)) {
-            reportError("M001", (_a = parent === null || parent === void 0 ? void 0 : parent.type) !== null && _a !== void 0 ? _a : "Root", def.type);
-            // continuation.cancel = true;
-            return;
-        }
-        // --- Rule: an ID must be a valid JavaScript identifier
-        if (def.uid) {
-            if (!isValidIdentifier(def.uid)) {
-                reportError("M002", def.type, def.type, def.uid);
-            }
-            else if (componentIdsCollected.has(def.uid)) {
-                reportError("M003", def.type, def.uid);
-            }
-            else {
-                componentIdsCollected.add(def.uid);
-            }
-        }
-        // --- Check all props of the component
-        const propDescriptors = (_b = metadataHandler.getComponentProps(def.type)) !== null && _b !== void 0 ? _b : {};
-        const currentProps = (_c = def.props) !== null && _c !== void 0 ? _c : {};
-        for (const propName of Object.keys(currentProps)) {
-            const propDescriptor = propDescriptors[propName];
-            // --- Rule: The property must be defined in the component descriptor or be a layout option
-            // --- or the component must accept arbitrary properties
-            if (propDescriptor) {
-                // --- The property has a descriptor, so it is allowed.
-                // --- Rule: The property value must be parseable
-                const propValue = currentProps[propName];
-                if (typeof propValue === "string") {
-                    try {
-                        (0, ParameterParser_1.parseParameterString)(propValue);
-                    }
-                    catch (error) {
-                        reportError("M006", def.type, propName, error.message);
-                    }
-                }
-            }
-            else {
-                // --- The property has no descriptor.
-                const propParts = propName.split("-");
-                // --- Check for a layout property
-                const validProp = 
-                // --- Layout property
-                (propParts.length === 1 && descriptorHelper_1.layoutOptionKeys.includes(propName)) ||
-                    // --- Layout property with viewport size
-                    (propParts.length === 2 &&
-                        descriptorHelper_1.layoutOptionKeys.includes(propParts[0]) &&
-                        abstractions_1.viewportSizeNames.includes(propParts[1])) ||
-                    // --- Arbitrary property is allowed
-                    metadataHandler.acceptArbitraryProps(def.type);
-                if (!validProp) {
-                    // --- The component does not accept arbitrary properties and
-                    // --- the property is not a layout option
-                    reportError("M005", def.type, def.type, propName);
-                }
-            }
-        }
-        // --- Check all events of the component
-        const eventDescriptors = (_d = metadataHandler.getComponentEvents(def.type)) !== null && _d !== void 0 ? _d : {};
-        const currentEvents = (_e = def.events) !== null && _e !== void 0 ? _e : {};
-        for (const eventName of Object.keys(currentEvents)) {
-            const eventDescriptor = eventDescriptors[eventName];
-            // --- Rule: The event must be defined in the component descriptor
-            if (eventDescriptor) {
-                // --- The event has a descriptor, so it is allowed.
-                const eventValue = currentEvents[eventName];
-                if (typeof eventValue === "string") {
-                    // --- Rule: The event value must be parseable
-                    const parser = new Parser_1.Parser(eventValue);
-                    try {
-                        parser.parseStatements();
-                        if (parser.errors.length > 0) {
-                            reportError("M012", def.type, eventName, parser.errors[0].text);
-                        }
-                    }
-                    catch (error) {
-                        reportError("M012", def.type, eventName, error.message);
-                    }
-                }
-            }
-            else {
-                reportError("M011", def.type, def.type, eventName);
-            }
-        }
-        // --- Check the component validator
-        const componentValidator = metadataHandler.getComponentValidator(def.type);
-        if (componentValidator) {
-            const validationErrors = componentValidator(def, devMode);
-            if (validationErrors) {
-                if (Array.isArray(validationErrors)) {
-                    for (const error of validationErrors) {
-                        reportError("M013", def.type, error);
-                    }
-                }
-                else {
-                    reportError("M013", def.type, validationErrors);
-                }
-            }
-        }
-    }
-    /**
-     * Checks if a string is a valid JavaScript identifier.
-     * @param identifier The string to check.
-     * @returns True if the string is a valid identifier, false otherwise.
-     */
-    function isValidIdentifier(identifier) {
-        const identifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-        return identifierRegex.test(identifier);
-    }
-    function reportError(code, name, ...args) {
-        _reportError(code, name, false, ...args);
-    }
-    function reportWarning(code, name, ...args) {
-        _reportError(code, name, true, ...args);
-    }
-    function _reportError(code, name, isWarning, ...args) {
-        var _a;
-        let errorText = (_a = errorMessages[code]) !== null && _a !== void 0 ? _a : "Unkonwn error";
-        if (args) {
-            args.forEach((a, idx) => (errorText = replace(errorText, `{${idx}}`, args[idx].toString())));
-        }
-        errorsCollected.push({ name, code, message: errorText, isWarning, args });
-        function replace(input, placeholder, replacement) {
-            do {
-                input = input.replace(placeholder, replacement);
-            } while (input.includes(placeholder));
-            return input;
-        }
-    }
-}
-// --- This function visits a component, its nested components and children
-function visitComponent(def, parent, visitor, continuation = {}, metadataHandler) {
-    var _a, _b, _c, _d;
-    // --- Visit the component (before)
-    visitor(def, parent, true, continuation);
-    if (continuation.abort || continuation.cancel) {
-        // --- Stop the visit
-        return;
-    }
-    // --- Visit the properties with "ComponentDef" value
-    const propDescriptors = (_a = metadataHandler.getComponentProps(def.type)) !== null && _a !== void 0 ? _a : {};
-    const currentProps = (_b = def.props) !== null && _b !== void 0 ? _b : {};
-    for (const propName of Object.keys(currentProps)) {
-        const propDescriptor = propDescriptors[propName];
-        if (!propDescriptor) {
-            // --- No descriptor for the property, skip it
-            continue;
-        }
-        const propValue = currentProps[propName];
-        if (propDescriptor.type === "ComponentDef" && propValue.type) {
-            // --- This property holds a nested component, visit it
-            visitComponent(propValue, def, visitor, continuation, metadataHandler);
-            if (continuation.abort || continuation.cancel) {
-                // --- Stop the visit
-                return;
-            }
-        }
-    }
-    // --- Visit events with nested components
-    const eventDescriptors = (_c = metadataHandler.getComponentEvents(def.type)) !== null && _c !== void 0 ? _c : {};
-    const currentEvents = (_d = def.events) !== null && _d !== void 0 ? _d : {};
-    for (const eventName of Object.keys(currentEvents)) {
-        const eventDescriptor = eventDescriptors[eventName];
-        if (!eventDescriptor) {
-            // --- No descriptor for the events, skip it
-            continue;
-        }
-        const eventValue = currentEvents[eventName];
-        if (typeof eventValue === "object" && eventValue.type) {
-            // --- This event holds a nested component, visit it
-            visitComponent(eventValue, def, visitor, continuation, metadataHandler);
-            if (continuation.abort) {
-                // --- Stop visiting this component
-                return;
-            }
-            if (continuation.cancel) {
-                // --- Skip the remaining items
-                break;
-            }
-        }
-    }
-    // --- Visit the component children
-    if (def.children) {
-        for (const child of def.children) {
-            visitComponent(child, def, visitor, continuation, metadataHandler);
-            if (continuation.abort) {
-                // --- Stop visiting this component
-                return;
-            }
-            if (continuation.cancel) {
-                // --- Skip the remaining items
-                break;
-            }
-        }
-    }
-    // --- Visit the component (after)
-    visitor(def, undefined, false, continuation);
-}
-// --- The error messages of error codes
-const errorMessages = {
-    M001: "The component '{0}' is not registered",
-    M002: "The '{0}' element has an invalid id: '{1}'",
-    M003: "Invalid component identifier: '{0}'",
-    M004: "Duplicated component identifier: '{0}'",
-    M005: "The '{0}' element has an invalid property: '{1}'",
-    M006: "Parsing property value of '{0}' failed: {1}",
-    M007: "The name of a reusable component is invalid: '{0}'",
-    M008: "The name of a reusable component must not be '{0}', as it is a reserved name",
-    M009: "A reusable component cannot have the name of a registered component: '{0}'",
-    M010: "Duplicated reusable component name: '{0}'",
-    M011: "The '{0}' element has an invalid event: '{1}'",
-    M012: "Parsing event value of '{0}' failed: {1}",
-    M013: "Component validation failed: '{0}'",
-};

package/dist/scripts/src/components-core/parts.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PART_THUMB = exports.PART_RANGE = exports.PART_TRACK = exports.PART_END_ADORNMENT = exports.PART_START_ADORNMENT = exports.PART_INPUT = exports.PART_LABELED_ITEM = exports.PART_LABEL = void 0;
-exports.PART_LABEL = "label";
-exports.PART_LABELED_ITEM = "labeledItem";
-exports.PART_INPUT = "input";
-exports.PART_START_ADORNMENT = "startAdornment";
-exports.PART_END_ADORNMENT = "endAdornment";
-exports.PART_TRACK = "track";
-exports.PART_RANGE = "range";
-exports.PART_THUMB = "thumb";

package/dist/scripts/src/components-core/renderers.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createComponentRenderer = createComponentRenderer;
-exports.createPropHolderComponent = createPropHolderComponent;
-exports.createLoaderRenderer = createLoaderRenderer;
-exports.createUserDefinedComponentRenderer = createUserDefinedComponentRenderer;
-/**
- * This helper function creates a component renderer definition from its arguments.
- * @param type The unique identifier of the component definition
- * @param renderer The function that renders the component definition into a React node
- * @param metadata Optional hints to help fix the rendering errors coming from invalid component property definitions
- * @returns The view renderer definition composed of the arguments
- */
-function createComponentRenderer(type, metadata, renderer) {
-    return {
-        type,
-        renderer,
-        metadata,
-    };
-}
-/**
- * Create a non-visual component used for encapsulating property values
- * @param type Component type
- * @param metadata Component metadata
- */
-function createPropHolderComponent(type, metadata) {
-    return createComponentRenderer(type, metadata, () => {
-        throw new Error("Prop holder component, shouldn't render");
-    });
-}
-/**
- * AppEngine uses React as its UI framework to declare and render loaders. This type declares a function that renders
- * a particular loader definition into its React representation.
- *
- * The type parameter of the function refers to the loader definition the function is about to render.
- * @param type The unique ID of the loader
- * @param renderer The function that renders the loader
- * @param hints Optional hints to help fix the rendering errors coming from invalid component property definitions
- */
-function createLoaderRenderer(type, renderer, hints) {
-    return {
-        type,
-        renderer,
-        hints,
-    };
-}
-/**
- * This helper function creates a user defined component renderer definition from its arguments.
- * @param metadata The metadata of the user-defined component
- * @param componentMarkup The XMLUI markup that defines the user-defined component
- * @param codeBehind Optional code-behind script that contains variable and function definitions
- * used by the component
- * @returns The view renderer definition composed of the arguments
- */
-function createUserDefinedComponentRenderer(metadata, def, codeBehind) {
-    var _a, _b;
-    // --- Parse the component definition from the markup
-    // --- Parse the optional code-behind script
-    const component = def.component.component;
-    ;
-    if (codeBehind) {
-        if (codeBehind.vars) {
-            (_a = component.vars) !== null && _a !== void 0 ? _a : (component.vars = {});
-            component.vars = Object.assign(Object.assign({}, component.vars), codeBehind.vars);
-        }
-        if (codeBehind.functions) {
-            (_b = component.functions) !== null && _b !== void 0 ? _b : (component.functions = {});
-            component.functions = Object.assign(Object.assign({}, component.functions), codeBehind.functions);
-        }
-    }
-    // --- Done.
-    return {
-        compoundComponentDef: def.component,
-        metadata,
-    };
-}