@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/icon.js

@@ -0,0 +1,307 @@
+import { state, property, customElement } from "lit/decorators.js";
+import { css, LitElement, html, nothing } from "lit";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+import { until } from "lit/directives/until.js";
+import { hostAttributes } from "./core/decorators.js";
+import { readConfig } from "./core/config.js";
+const isStr = (val) => typeof val === "string";
+const isValid = (elm) => {
+  if (elm.nodeType === 1) {
+    if (elm.nodeName.toLowerCase() === "script") {
+      return false;
+    }
+    for (let i = 0; i < elm.attributes.length; i++) {
+      const val = elm.attributes[i].name;
+      if (isStr(val) && val.toLowerCase().indexOf("on") === 0) {
+        return false;
+      }
+    }
+    for (let i = 0; i < elm.childNodes.length; i++) {
+      if (!isValid(elm.childNodes[i])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+const validateContent = (svgContent, sanitize = true, colorImmutable = false) => {
+  const div = document.createElement("div");
+  div.innerHTML = svgContent;
+  for (let i = div.childNodes.length - 1; i >= 0; i--) {
+    if (div.childNodes[i].nodeName.toLowerCase() !== "svg") {
+      div.removeChild(div.childNodes[i]);
+    }
+  }
+  const svgElm = div.firstElementChild;
+  if (svgElm && svgElm.nodeName.toLowerCase() === "svg") {
+    if (colorImmutable && !svgElm.classList.contains("color-immutable")) {
+      svgElm.classList.add("color-immutable");
+    }
+    if (sanitize === false) {
+      return div.innerHTML;
+    }
+    if (isValid(svgElm)) {
+      return div.innerHTML;
+    }
+  }
+  return "";
+};
+const iconCdn = "https://icons.app.sbb.ch/";
+const iconNamespaces = (/* @__PURE__ */ new Map()).set("default", `${iconCdn}icons/`).set("picto", `${iconCdn}picto/`);
+const requests = /* @__PURE__ */ new Map();
+const getSvgContent = (namespace, name, sanitize) => {
+  var _a;
+  const config = readConfig().icon ?? {};
+  const resolvedNamespace = ((_a = config.namespaces) == null ? void 0 : _a.get(namespace)) ?? iconNamespaces.get(namespace);
+  if (resolvedNamespace === void 0) {
+    throw Error(
+      `Unable to find the namespace "${namespace}". Please register your custom namespace.`
+    );
+  }
+  const url = `${resolvedNamespace}${name}.svg`;
+  let req = requests.get(url);
+  if (!req) {
+    if (typeof fetch !== "undefined" && typeof document !== "undefined") {
+      const interceptor = config.interceptor ?? ((i) => i.request());
+      req = interceptor({
+        namespace,
+        name,
+        url,
+        request: () => fetch(url).then((rsp) => {
+          if (rsp.ok) {
+            return rsp.text().then((svgContent) => {
+              if (svgContent) {
+                svgContent = validateContent(svgContent, sanitize);
+              }
+              return svgContent;
+            });
+          }
+          throw new Error("Failed to load icon " + namespace + ":" + name);
+        }).catch((error) => {
+          throw Error(error);
+        })
+      });
+      requests.set(url, req);
+    } else {
+      return Promise.resolve("");
+    }
+  }
+  return req;
+};
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  display: inline-block;
+  line-height: 0;
+  -webkit-tap-highlight-color: transparent;
+}
+
+:host([data-empty]) {
+  --sbb-icon-default-dimension: 0;
+}
+
+:host([data-empty][data-namespace=default][name$=-small]) {
+  --sbb-icon-default-dimension: var(--sbb-size-icon-ui-small);
+}
+
+:host([data-empty][data-namespace=default][name$=-medium]) {
+  --sbb-icon-default-dimension: var(--sbb-size-icon-ui-medium);
+}
+
+:host([data-empty][data-namespace=default][name$=-large]) {
+  --sbb-icon-default-dimension: var(--sbb-size-icon-ui-large);
+}
+
+svg {
+  width: var(--sbb-icon-svg-width, var(--sbb-icon-default-dimension));
+  height: var(--sbb-icon-svg-height, var(--sbb-icon-default-dimension));
+  stroke: var(--sbb-icon-svg-stroke-color);
+  stroke-width: var(--sbb-icon-svg-stroke-width);
+}
+svg:not(.color-immutable) [fill]:not([fill=none]) {
+  fill: currentcolor;
+}
+svg:not(.color-immutable) [stroke]:not([stroke=none]) {
+  stroke: currentcolor;
+}
+svg:not(.color-immutable) > :where(path, polygon, polyline):where(:not([stroke]):not([fill])),
+svg:not(.color-immutable) :where(:not([stroke]):not([fill])) :where(path, polygon, polyline):where(:not([stroke]):not([fill])) {
+  fill: currentcolor;
+}`;
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$2(target, key, result);
+  return result;
+};
+let SbbIconBase = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this._svgNamespace = SbbIconBase._defaultNamespace;
+    this.noSanitize = false;
+  }
+  async loadSvgIcon(iconName) {
+    if (!iconName) {
+      return;
+    }
+    const [namespace, name] = this._splitIconName(iconName);
+    this._svgNamespace = namespace;
+    this.setAttribute("data-namespace", this._svgNamespace);
+    const svgIcon = this.fetchSvgIcon(this._svgNamespace, name);
+    this._svgIcon = svgIcon.then((v) => unsafeHTML(v));
+    try {
+      this.toggleAttribute("data-empty", !await svgIcon);
+    } catch {
+      this.toggleAttribute("data-empty", true);
+    }
+  }
+  async fetchSvgIcon(namespace, name) {
+    return await getSvgContent(namespace, name, !this.noSanitize);
+  }
+  _splitIconName(iconName) {
+    if (!iconName) {
+      return ["", ""];
+    }
+    const parts = iconName.split(":");
+    switch (parts.length) {
+      case 1:
+        return [SbbIconBase._defaultNamespace, parts[0]];
+      case 2:
+        return parts;
+      default:
+        throw Error(`Invalid icon name: "${iconName}"`);
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this.setAttribute("role", this.getAttribute("role") ?? "img");
+  }
+  render() {
+    return html`<span class="sbb-icon-inner"
+      >${until(
+      this._svgIcon,
+      // To reserve space, we need an empty svg to apply dimension to.
+      html`<svg width="0" height="0"></svg>`
+    )}</span
+    >`;
+  }
+};
+SbbIconBase.styles = style;
+SbbIconBase._defaultNamespace = "default";
+__decorateClass$2([
+  state()
+], SbbIconBase.prototype, "_svgNamespace", 2);
+__decorateClass$2([
+  state()
+], SbbIconBase.prototype, "_svgIcon", 2);
+__decorateClass$2([
+  property({ attribute: "no-sanitize", type: Boolean })
+], SbbIconBase.prototype, "noSanitize", 2);
+SbbIconBase = __decorateClass$2([
+  hostAttributes({
+    "data-namespace": SbbIconBase._defaultNamespace,
+    "data-empty": ""
+  })
+], SbbIconBase);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$1(target, key, result);
+  return result;
+};
+let SbbIconElement = class extends SbbIconBase {
+  constructor() {
+    super(...arguments);
+    this._defaultAriaLabel = "";
+  }
+  async fetchSvgIcon(namespace, name) {
+    if (this.getAttribute("aria-label") === this._defaultAriaLabel) {
+      this.removeAttribute("aria-label");
+    }
+    this._defaultAriaLabel = `Icon ${name.replace(/-/g, " ")}`;
+    if (this.getAttribute("aria-hidden") === "false" && !this.hasAttribute("aria-label") && name) {
+      this.setAttribute("aria-label", this._defaultAriaLabel);
+    }
+    return super.fetchSvgIcon(namespace, name);
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("name")) {
+      this.loadSvgIcon(this.name);
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    if (!this.hasAttribute("aria-hidden")) {
+      this.setAttribute("aria-hidden", "true");
+    }
+  }
+};
+__decorateClass$1([
+  property({ reflect: true })
+], SbbIconElement.prototype, "name", 2);
+SbbIconElement = __decorateClass$1([
+  customElement("sbb-icon")
+], SbbIconElement);
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(target, key, result) || result;
+  if (result)
+    __defProp(target, key, result);
+  return result;
+};
+const SbbIconNameMixin = (superClass) => {
+  class SbbIconNameElement extends superClass {
+    renderIconSlot(classname) {
+      return html`
+        <slot name="icon">
+          ${this.iconName ? html`<sbb-icon name=${this.iconName} class=${classname || nothing}></sbb-icon>` : nothing}
+        </slot>
+      `;
+    }
+  }
+  __decorateClass([
+    property({ attribute: "icon-name", reflect: true })
+  ], SbbIconNameElement.prototype, "iconName");
+  return SbbIconNameElement;
+};
+export {
+  SbbIconBase,
+  SbbIconElement,
+  SbbIconNameMixin,
+  getSvgContent,
+  isValid,
+  validateContent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"icon.js","sources":["../../../src/elements/icon/icon-validate.ts","../../../src/elements/icon/icon-request.ts","../../../src/elements/icon/icon-base.ts","../../../src/elements/icon/icon.ts","../../../src/elements/icon/icon-name-mixin.ts"],"sourcesContent":["const isStr = (val: any): val is string => typeof val === 'string';\n\n/**\n * Sanitizes the SVG element and all its child nodes.\n * Does not allow `<script>` elements, or any attributes that start with `on`, such as `onclick`.\n */\nexport const isValid = (elm: HTMLElement): boolean => {\n  if (elm.nodeType === 1) {\n    // is an Element node like <div>, <p> or <svg>\n    if (elm.nodeName.toLowerCase() === 'script') {\n      return false;\n    }\n\n    // do not allow attributes starting with `on`\n    for (let i = 0; i < elm.attributes.length; i++) {\n      const val = elm.attributes[i].name;\n      if (isStr(val) && val.toLowerCase().indexOf('on') === 0) {\n        return false;\n      }\n    }\n\n    for (let i = 0; i < elm.childNodes.length; i++) {\n      if (!isValid(elm.childNodes[i] as any)) {\n        return false;\n      }\n    }\n  }\n  return true;\n};\n\n/**\n * Validates the SVG content by checking that it has only one root element `<svg>`,\n * adding the `color-immutable` class if the `colorImmutable` option is set to `true`,\n * and sanitizing the provided content as long as the `sanitize` property is not explicitly set to `false`.\n */\nexport const validateContent = (\n  svgContent: string,\n  sanitize = true,\n  colorImmutable = false,\n): string => {\n  const div = document.createElement('div');\n  div.innerHTML = svgContent;\n\n  for (let i = div.childNodes.length - 1; i >= 0; i--) {\n    if (div.childNodes[i].nodeName.toLowerCase() !== 'svg') {\n      div.removeChild(div.childNodes[i]);\n    }\n  }\n\n  // must only have 1 root element\n  const svgElm = div.firstElementChild;\n\n  if (svgElm && svgElm.nodeName.toLowerCase() === 'svg') {\n    if (colorImmutable && !svgElm.classList.contains('color-immutable')) {\n      svgElm.classList.add('color-immutable');\n    }\n\n    // do not sanitize the svg element\n    if (sanitize === false) {\n      return div.innerHTML;\n    }\n\n    // sanitize the svg element\n    if (isValid(svgElm as any)) {\n      return div.innerHTML;\n    }\n  }\n  return '';\n};\n","import type { SbbIconConfig } from '../core/config.js';\nimport { readConfig } from '../core/config.js';\n\nimport { validateContent } from './icon-validate.js';\n\nconst iconCdn = 'https://icons.app.sbb.ch/';\n\nconst iconNamespaces = new Map<string, string>()\n  .set('default', `${iconCdn}icons/`)\n  .set('picto', `${iconCdn}picto/`);\nconst requests = new Map<string, Promise<any>>();\n\n/** Fetches icon svg content from providers and asserts only one request per icon is made. */\nexport const getSvgContent = (\n  namespace: string,\n  name: string,\n  sanitize: boolean,\n): Promise<string> => {\n  const config: SbbIconConfig = readConfig().icon ?? {};\n\n  const resolvedNamespace = config.namespaces?.get(namespace) ?? iconNamespaces.get(namespace);\n  if (resolvedNamespace === undefined) {\n    throw Error(\n      `Unable to find the namespace \"${namespace}\". Please register your custom namespace.`,\n    );\n  }\n  const url = `${resolvedNamespace}${name}.svg`;\n\n  // Check if we already have a request for this url\n  let req = requests.get(url);\n\n  if (!req) {\n    if (typeof fetch !== 'undefined' && typeof document !== 'undefined') {\n      const interceptor = config.interceptor ?? ((i) => i.request());\n\n      req = interceptor({\n        namespace,\n        name,\n        url,\n        request: () =>\n          fetch(url)\n            .then((rsp) => {\n              if (rsp.ok) {\n                return rsp.text().then((svgContent) => {\n                  if (svgContent) {\n                    svgContent = validateContent(svgContent, sanitize);\n                  }\n                  return svgContent;\n                });\n              }\n              throw new Error('Failed to load icon ' + namespace + ':' + name);\n            })\n            .catch((error) => {\n              throw Error(error);\n            }),\n      });\n      // Cache for the same requests\n      requests.set(url, req);\n    } else {\n      // Resolve promise for ssr scenarios\n      return Promise.resolve('');\n    }\n  }\n\n  return req;\n};\n","import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, LitElement } from 'lit';\nimport { property, state } from 'lit/decorators.js';\nimport type { DirectiveResult } from 'lit/directive.js';\nimport type { UnsafeHTMLDirective } from 'lit/directives/unsafe-html.js';\nimport { unsafeHTML } from 'lit/directives/unsafe-html.js';\nimport { until } from 'lit/directives/until.js';\n\nimport { hostAttributes } from '../core/decorators.js';\n\nimport { getSvgContent } from './icon-request.js';\nimport style from './icon.scss?lit&inline';\n\n/**\n * @cssprop [--sbb-icon-svg-width=auto] - Can be used to set a custom width.\n * @cssprop [--sbb-icon-svg-height=auto] - Can be used to set a custom height.\n */\n@hostAttributes({\n  'data-namespace': SbbIconBase._defaultNamespace,\n  'data-empty': '',\n})\nexport abstract class SbbIconBase extends LitElement {\n  public static override styles: CSSResultGroup = style;\n  private static readonly _defaultNamespace = 'default';\n\n  @state() private _svgNamespace = SbbIconBase._defaultNamespace;\n\n  /**\n   * The icon svg content rendered on the page: <svg>...</svg>.\n   */\n  @state() private _svgIcon?: Promise<DirectiveResult<typeof UnsafeHTMLDirective>>;\n\n  /**\n   * When set to `true`, SVG content that is HTTP fetched will not be checked\n   * if the response SVG content has any `<script>` elements, or any attributes\n   * that start with `on`, such as `onclick`.\n   * @default false\n   */\n  @property({ attribute: 'no-sanitize', type: Boolean }) public noSanitize = false;\n\n  protected async loadSvgIcon(iconName: string): Promise<void> {\n    if (!iconName) {\n      return;\n    }\n\n    const [namespace, name] = this._splitIconName(iconName);\n    this._svgNamespace = namespace;\n    this.setAttribute('data-namespace', this._svgNamespace);\n\n    const svgIcon = this.fetchSvgIcon(this._svgNamespace, name);\n    this._svgIcon = svgIcon.then((v) => unsafeHTML(v));\n    try {\n      this.toggleAttribute('data-empty', !(await svgIcon));\n    } catch {\n      this.toggleAttribute('data-empty', true);\n    }\n  }\n\n  protected async fetchSvgIcon(namespace: string, name: string): Promise<string> {\n    return await getSvgContent(namespace, name, !this.noSanitize);\n  }\n\n  private _splitIconName(iconName: string): [string, string] {\n    if (!iconName) {\n      return ['', ''];\n    }\n    const parts = iconName.split(':');\n    switch (parts.length) {\n      case 1:\n        // Use default namespace if empty.\n        return [SbbIconBase._defaultNamespace, parts[0]];\n      case 2:\n        return parts as [string, string];\n      default:\n        throw Error(`Invalid icon name: \"${iconName}\"`);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this.setAttribute('role', this.getAttribute('role') ?? 'img');\n  }\n\n  protected override render(): TemplateResult {\n    return html`<span class=\"sbb-icon-inner\"\n      >${until(\n        this._svgIcon,\n        // To reserve space, we need an empty svg to apply dimension to.\n        html`<svg width=\"0\" height=\"0\"></svg>`,\n      )}</span\n    >`;\n  }\n}\n","import type { PropertyValues } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { SbbIconBase } from './icon-base.js';\n\n/**\n * It displays an icon loaded from a registered namespace.\n */\n@customElement('sbb-icon')\nexport class SbbIconElement extends SbbIconBase {\n  /**\n   * The provided name consisting of the namespace and the name of the icon.\n   * If the namespace is missing, the default namespace \"sbb\" will be used.\n   * E.g. `name` (will use \"sbb\" as namespace) or `namespace:name`.\n   */\n  @property({ reflect: true }) public name!: string;\n\n  private _defaultAriaLabel = '';\n\n  protected override async fetchSvgIcon(namespace: string, name: string): Promise<string> {\n    // If the icon is changing, and we were using the defaultAriaLabel, reset it\n    if (this.getAttribute('aria-label') === this._defaultAriaLabel) {\n      this.removeAttribute('aria-label');\n    }\n\n    this._defaultAriaLabel = `Icon ${name.replace(/-/g, ' ')}`;\n\n    // generate a default label in case user does not provide their own\n    // and aria-hidden is set to \"false\"\n    if (this.getAttribute('aria-hidden') === 'false' && !this.hasAttribute('aria-label') && name) {\n      this.setAttribute('aria-label', this._defaultAriaLabel);\n    }\n\n    return super.fetchSvgIcon(namespace, name);\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('name')) {\n      this.loadSvgIcon(this.name);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    if (!this.hasAttribute('aria-hidden')) {\n      this.setAttribute('aria-hidden', 'true');\n    }\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-icon': SbbIconElement;\n  }\n}\n","import { html, type LitElement, nothing, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from '../core/mixins.js';\n\nimport './icon.js';\n\nexport declare class SbbIconNameMixinType {\n  public iconName?: string;\n  protected renderIconSlot(classname?: string): TemplateResult;\n}\n\n/**\n * Enhance your component with an iconName property and provides a template for the icon slot.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbIconNameMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbIconNameMixinType> & T => {\n  abstract class SbbIconNameElement extends superClass implements Partial<SbbIconNameMixinType> {\n    /**\n     * The icon name we want to use, choose from the small icon variants\n     * from the ui-icons category from here\n     * https://icons.app.sbb.ch.\n     */\n    @property({ attribute: 'icon-name', reflect: true }) public iconName?: string;\n\n    protected renderIconSlot(classname?: string): TemplateResult {\n      return html`\n        <slot name=\"icon\">\n          ${this.iconName\n            ? html`<sbb-icon name=${this.iconName} class=${classname || nothing}></sbb-icon>`\n            : nothing}\n        </slot>\n      `;\n    }\n  }\n\n  return SbbIconNameElement as unknown as AbstractConstructor<SbbIconNameMixinType> & T;\n};\n"],"names":["__decorateClass"],"mappings":"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"}

package/development/image/image.d.ts

@@ -0,0 +1,236 @@
+import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
+
+export interface InterfaceImageAttributesSizesConfig {
+    breakpoints: InterfaceImageAttributesSizesConfigBreakpoint[];
+}
+export interface InterfaceImageAttributesSizesConfigBreakpoint {
+    image: {
+        height: number;
+        width: number;
+    };
+    mediaQueries: InterfaceImageAttributesSizesConfigMediaQuery[];
+}
+export interface InterfaceImageAttributesSizesConfigMediaQuery {
+    conditionFeature: string;
+    conditionFeatureValue: {
+        lyneDesignToken: boolean;
+        value: string;
+    };
+    conditionOperator: false;
+}
+/**
+ * It displays an image.
+ *
+ * @cssprop [--sbb-image-aspect-ratio=auto] - Can be used to override `aspectRatio` property.
+ * This way we can have, for example, an image component with an aspect
+ * ratio of 4/3 in smaller viewports and 16/9 in larger viewports.
+ * @cssprop [--sbb-image-border-radius=var(--sbb-border-radius-4x)] - Can be used to override the
+ * `borderRadius` property in case of different values for different viewports.
+ */
+export declare class SbbImageElement extends LitElement {
+    static styles: CSSResultGroup;
+    private _captionElement?;
+    private _linksInCaption?;
+    private _config;
+    /**
+     * An alt text is not always necessary (e.g. in teaser cards when
+     * additional link text is provided). In this case we can leave
+     * the value of the alt attribute blank, but the attribute itself
+     * still needs to be present. That way we can signal assistive
+     * technology, that they can skip the image.
+     */
+    alt?: string;
+    /**
+     * If set to false, we show a blurred version of the image as
+     * placeholder before the actual image shows up. This will help
+     * to improve the perceived loading performance. Read more about
+     * the idea of lqip here:
+     * https://medium.com/@imgix/lqip-your-images-for-fast-loading-2523d9ee4a62
+     */
+    skipLqip: boolean;
+    /**
+     * A caption can provide additional context to the image (e.g.
+     * descriptions and the like).
+     * Links will automatically receive tabindex=-1 if hideFromScreenreader
+     * is set to true. That way they will no longer become focusable.
+     */
+    caption?: string;
+    /**
+     * If a copyright text is provided, we will add it to the caption
+     * and create a structured data json-ld block with the copyright
+     * information.
+     */
+    copyright?: string;
+    /**
+     * Copyright holder can either be an Organization or a Person
+     */
+    copyrightHolder: 'Organization' | 'Person';
+    /**
+     * Set this to true, if you want to pass a custom focal point
+     * for the image. See full documentation here:
+     * https://docs.imgix.com/apis/rendering/focalpoint-crop
+     */
+    customFocalPoint: boolean;
+    /**
+     * If the lazy property is set to true, the module will automatically
+     * change the decoding to async, otherwise the decoding is set to auto
+     * which leaves the handling up to the browser. Read more about the
+     * decoding attribute here:
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decoding
+     */
+    decoding: 'sync' | 'async' | 'auto';
+    /**
+     * Set this to true, to receive visual guidance where the custom focal
+     * point is currently set.
+     */
+    focalPointDebug: boolean;
+    /**
+     * Pass in a floating number between 0 (left) and 1 (right).
+     */
+    focalPointX: number;
+    /**
+     * Pass in a floating number between 0 (top) and 1 (bottom).
+     */
+    focalPointY: number;
+    /**
+     * Right now the module is heavily coupled with the image delivery
+     * service imgix and depends on the original files being stored
+     * inside AEM. You can pass in any https://cdn.img.sbb.ch img
+     * src address you find on sbb.ch to play around with it. Just
+     * strip the url parameters and paste in the plain file address.
+     * If you want to know how to best work with this module with
+     * images coming from a different source, please contact the
+     * LYNE Core Team.
+     */
+    imageSrc?: string;
+    /**
+     * The importance attribute is fairly new attribute which should
+     * help the browser decide which resources it should prioritise
+     * during page load. We will set the attribute value based on the
+     * value, we receive in the loading attribute. 'eager', which we use
+     * for the largest image within the initial viewport, will set the
+     * attribute value to 'high'. 'lazy', which we use for images below
+     * the fold, will set the attribute value to 'low'.
+     */
+    importance: 'auto' | 'high' | 'low';
+    /**
+     * With the support of native image lazy loading, we can now
+     * decide whether we want to load the image immediately or only
+     * once it is close to the visible viewport. The value eager is
+     * best used for images within the initial viewport. We want to
+     * load these images as fast as possible to improve the Core Web
+     * Vitals values. lazy on the other hand works best for images
+     * which are further down the page or invisible during the loading
+     * of the initial viewport.
+     */
+    loading: 'eager' | 'lazy';
+    /**
+     * With performance.mark you can log a timestamp associated with
+     * the name you define in performanceMark when a certain event is
+     * happening. In our case we will log the performance.mark into
+     * the PerformanceEntry API once the image is fully loaded.
+     * Performance monitoring tools like SpeedCurve or Lighthouse are
+     * then able to grab these entries from the PerformanceEntry API
+     * and give us additional information and insights about our page
+     * loading behaviour. We are then also able to monitor these
+     * values over a long period to see if our performance
+     * increases or decreases over time. Best to use lowercase strings
+     * here, separate words with underscores or dashes.
+     */
+    performanceMark?: string;
+    /**
+     * With the pictureSizesConfig object, you can pass in information
+     * into image about what kind of source elements should get
+     * rendered. mediaQueries accepts multiple Media Query entries
+     * which can get combined by defining a conditionOperator.
+     * Type is: stringified InterfaceImageAttributesSizesConfig-Object
+     * An example could look like this:
+     * {
+     *    "breakpoints": [
+     *      {
+     *        "image": {
+     *          "height": "675",
+     *          "width": "1200"
+     *        },
+     *        "mediaQueries": [
+     *          {
+     *            "conditionFeature": "min-width",
+     *            "conditionFeatureValue": {
+     *              "lyneDesignToken": true,
+     *              "value": "sbb-breakpoint-large-min"
+     *            },
+     *            "conditionOperator": false
+     *          }
+     *        ]
+     *      },
+     *      {
+     *        "image": {
+     *          "height": "549",
+     *          "width": "976"
+     *        },
+     *        "mediaQueries": [
+     *          {
+     *            "conditionFeature": "min-width",
+     *            "conditionFeatureValue": {
+     *              "lyneDesignToken": true,
+     *              "value": "sbb-breakpoint-small-min"
+     *            },
+     *            "conditionOperator": false
+     *          }
+     *        ]
+     *      },
+     *      {
+     *        "image": {
+     *          "height": "180",
+     *          "width": "320"
+     *        },
+     *        "mediaQueries": [
+     *          {
+     *            "conditionFeature": "max-width",
+     *            "conditionFeatureValue": {
+     *              "lyneDesignToken": true,
+     *              "value": "sbb-breakpoint-micro-max"
+     *            },
+     *            "conditionOperator": "and"
+     *          },
+     *          {
+     *            "conditionFeature": "orientation",
+     *            "conditionFeatureValue": {
+     *              "lyneDesignToken": false,
+     *              "value": "landscape"
+     *            },
+     *            "conditionOperator": false
+     *          }
+     *        ]
+     *      }
+     *    ]
+     *  }
+     */
+    pictureSizesConfig?: string;
+    /**
+     * Border radius of the image. Choose between a default radius, no radius and a completely round image.
+     */
+    borderRadius: 'default' | 'none' | 'round';
+    /**
+     * Set an aspect ratio
+     * default is '16-9' (16/9)
+     * other values: 'free', '1-1', '1-2', '2-1', '2-3', '3-2', '3-4', '4-3', '4-5', '5-4', '9-16'
+     */
+    aspectRatio: 'free' | '1-1' | '1-2' | '2-1' | '2-3' | '3-2' | '3-4' | '4-3' | '4-5' | '5-4' | '9-16' | '16-9';
+    private _logPerformanceMarks;
+    private _matchMediaQueryDesignToken;
+    private _addFocusAbilityToLinksInCaption;
+    private _prepareImageUrl;
+    private _preparePictureSizeConfigs;
+    private _createMediaQueryString;
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private _imageLoaded;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-image': SbbImageElement;
+    }
+}
+//# sourceMappingURL=image.d.ts.map

package/development/image/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../../src/elements/image/image.ts"],"names":[],"mappings":"AAiBA,OAAO,EACL,KAAK,cAAc,EAEnB,UAAU,EAEV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAQb,MAAM,WAAW,mCAAmC;IAClD,WAAW,EAAE,6CAA6C,EAAE,CAAC;CAC9D;AAED,MAAM,WAAW,6CAA6C;IAC5D,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,YAAY,EAAE,6CAA6C,EAAE,CAAC;CAC/D;AAED,MAAM,WAAW,6CAA6C;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB,qBAAqB,EAAE;QACrB,eAAe,EAAE,OAAO,CAAC;QACzB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,iBAAiB,EAAE,KAAK,CAAC;CAC1B;AAkGD;;;;;;;;GAQG;AACH,qBACa,eAAgB,SAAQ,UAAU;IAC7C,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,OAAO,CAAC,eAAe,CAAC,CAAc;IACtC,OAAO,CAAC,eAAe,CAAC,CAA8B;IACtD,OAAO,CAAC,OAAO,CAGb;IAEF;;;;;;OAMG;IACgB,GAAG,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;;;OAMG;IACyD,QAAQ,UAAS;IAE7E;;;;;OAKG;IACgB,OAAO,CAAC,EAAE,MAAM,CAAC;IAEpC;;;;OAIG;IACgB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEtC;;OAEG;IAEI,eAAe,EAAE,cAAc,GAAG,QAAQ,CAAkB;IAEnE;;;;OAIG;IACkE,gBAAgB,UAAS;IAE9F;;;;;;OAMG;IACgB,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAU;IAEhE;;;OAGG;IACiE,eAAe,UAAS;IAE5F;;OAEG;IAC4D,WAAW,SAAK;IAE/E;;OAEG;IAC4D,WAAW,SAAK;IAE/E;;;;;;;;;OASG;IAC0C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE/D;;;;;;;;OAQG;IACgB,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAU;IAEhE;;;;;;;;;OASG;IACgB,OAAO,EAAE,OAAO,GAAG,MAAM,CAAW;IAEvD;;;;;;;;;;;;OAYG;IACiD,eAAe,CAAC,EAAE,MAAM,CAAC;IAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmEG;IACqD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAEpF;;OAEG;IAC6D,YAAY,EACxE,SAAS,GACT,MAAM,GACN,OAAO,CAAa;IAExB;;;;OAIG;IAEI,WAAW,EACd,MAAM,GACN,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,MAAM,GACN,MAAM,CAAU;IAEpB,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,2BAA2B;IAKnC,OAAO,CAAC,gCAAgC;IAMxC,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,0BAA0B;IAgElC,OAAO,CAAC,uBAAuB;IAuBf,iBAAiB,IAAI,IAAI;cAStB,MAAM,IAAI,cAAc;cAgGxB,OAAO,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAiBzE,OAAO,CAAC,YAAY;CAIrB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,WAAW,EAAE,eAAe,CAAC;KAC9B;CACF"}

package/development/image.d.ts

@@ -0,0 +1,2 @@
+export * from './image/image.js';
+//# sourceMappingURL=image.d.ts.map

package/development/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/elements/image.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}