@lmvz-ds/components 0.18.2 → 0.20.0

package/esm/{reactive-controller-host-sR2jJxNG.js → reactive-controller-host-DHcPpJW7.js}

@@ -1,4 +1,4 @@
-import { i as isAriaValidationEnabled, u as useVerboseLogging, A as ARIA_VALIDATION_RUNTIME_CHANGED_EVENT, q as queueValidation } from './aria-loader-BF_AYtbb.js';
+import { i as isAriaValidationEnabled, u as useVerboseLogging, A as ARIA_VALIDATION_RUNTIME_CHANGED_EVENT, q as queueValidation } from './aria-loader-BVolm0lC.js';
 import { B as Build } from './index-saW7O-EW.js';
 
 class AriaValidationController {
@@ -156,34 +156,34 @@ class ReactiveControllerHost {
         this.controllers.delete(controller);
     }
     get activeControllers() {
-        return Array.from(this.controllers).filter(controller => !controller.disabled);
+        return Array.from(this.controllers).filter((controller) => !controller.disabled);
     }
     connectedCallback() {
         if (!this.controllers.size) {
             console.warn('ReactiveControllerHost connected with no controllers registered.', this);
         }
-        this.activeControllers.forEach(controller => controller.hostConnected?.());
+        this.activeControllers.forEach((controller) => controller.hostConnected?.());
     }
     disconnectedCallback() {
-        this.activeControllers.forEach(controller => controller.hostDisconnected?.());
+        this.activeControllers.forEach((controller) => controller.hostDisconnected?.());
     }
     componentWillLoad() {
-        this.activeControllers.forEach(controller => controller.hostWillLoad?.());
+        this.activeControllers.forEach((controller) => controller.hostWillLoad?.());
     }
     componentDidLoad() {
-        this.activeControllers.forEach(controller => controller.hostDidLoad?.());
+        this.activeControllers.forEach((controller) => controller.hostDidLoad?.());
     }
     componentWillRender() {
-        this.activeControllers.forEach(controller => controller.hostWillRender?.());
+        this.activeControllers.forEach((controller) => controller.hostWillRender?.());
     }
     componentDidRender() {
-        this.activeControllers.forEach(controller => controller.hostDidRender?.());
+        this.activeControllers.forEach((controller) => controller.hostDidRender?.());
     }
     componentWillUpdate() {
-        this.activeControllers.forEach(controller => controller.hostWillUpdate?.());
+        this.activeControllers.forEach((controller) => controller.hostWillUpdate?.());
     }
     componentDidUpdate() {
-        this.activeControllers.forEach(controller => controller.hostDidUpdate?.());
+        this.activeControllers.forEach((controller) => controller.hostDidUpdate?.());
     }
 }
 

package/esm/svg-B2YoIRuh.js

@@ -0,0 +1,121 @@
+import { g as getOrThrowWith, r as right, l as left, i as identity, a as isRight, b as getRight, m as match, c as runSync, t as try_, T as TaggedError } from './logger-CGmJG63p.js';
+
+/**
+ * This module provides types and utility functions to create and work with branded types,
+ * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
+ *
+ * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
+ * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
+ *
+ * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
+ * This is useful when you want to distinguish between two values of the same type that have different meanings.
+ * The `nominal` function does not perform any validation of the input data.
+ *
+ * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
+ * but with a different name, and it also allows for validation of the input data.
+ * The `refined` function takes a predicate that is used to validate the input data.
+ * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
+/**
+ * Returns a `BrandErrors` that contains a single `RefinementError`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const error = (message, meta) => [{
+  message,
+  meta
+}];
+function refined(...args) {
+  const either = args.length === 2 ? unbranded => args[0](unbranded) ? right(unbranded) : left(args[1](unbranded)) : unbranded => {
+    return match(args[0](unbranded), {
+      onNone: () => right(unbranded),
+      onSome: left
+    });
+  };
+  return Object.assign(unbranded => getOrThrowWith(either(unbranded), identity), {
+    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
+    option: args => getRight(either(args)),
+    either,
+    is: args => isRight(either(args))
+  });
+}
+
+const SVGString = refined(isValidSVG, () => error('SVG data is malformed'));
+class BrandValidationError extends TaggedError('BrandValidationError') {
+    constructor(error, type) {
+        super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
+    }
+}
+/**
+ * Creates a synchronous Micro effect that validates a string against the branded `SVGString` type.
+ *
+ * @param svg Raw SVG markup to validate.
+ */
+const validateSvg = (svg) => try_({
+    try: () => SVGString(sanitizeSvg(svg)),
+    catch: (error) => new BrandValidationError(error, 'SVGString'),
+});
+/**
+ * Checks whether a string can be parsed into an SVG document.
+ *
+ * @param svg Raw SVG markup to validate.
+ */
+function isValidSVG(svg) {
+    if (typeof svg !== 'string')
+        return false;
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(svg, 'image/svg+xml');
+        return doc.documentElement.nodeName === 'svg';
+    }
+    catch {
+        return false;
+    }
+}
+function sanitizeSvg(svg) {
+    const dataUriPrefix = 'data:image/svg+xml,';
+    const dataUriPrefixWithEncoding = 'data:image/svg+xml;base64,';
+    const base = svg.trim();
+    if (base.startsWith(dataUriPrefixWithEncoding)) {
+        return atob(base.slice(dataUriPrefixWithEncoding.length));
+    }
+    return !base.startsWith(dataUriPrefix) ? base : decodeURIComponent(base.slice(dataUriPrefix.length));
+}
+/**
+ * Returns a valid, empty SVG.
+ */
+const emptyDefaultSvg = () => SVGString(`<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"></svg>`);
+/**
+ * Returns a valid SVG string, or a fallback empty SVG if the input is invalid.
+ *
+ * @param value The SVG string to validate.
+ */
+function toValidSvgStringWithFallback(value) {
+    try {
+        return runSync(validateSvg(value));
+    }
+    catch {
+        console.warn('Invalid SVG string:', value);
+        return emptyDefaultSvg();
+    }
+}
+function parseSvgString(value) {
+    try {
+        return runSync(validateSvg(value));
+    }
+    catch {
+        // this will be called by lmvz-icon, which might pass an icon name instead of an SVG string, so we log this at debug level to avoid spamming the console with warnings
+        console.debug('Invalid SVG string:', value);
+        return undefined;
+    }
+}
+
+export { emptyDefaultSvg as e, parseSvgString as p, toValidSvgStringWithFallback as t };