diff --git a/.changeset/big-geese-run.md b/.changeset/big-geese-run.md deleted file mode 100644 index 916c3afd8..000000000 --- a/.changeset/big-geese-run.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/input-tel-dropdown': minor ---- - -New component LionInpuTelDropdown diff --git a/.changeset/fifty-comics-attend.md b/.changeset/fifty-comics-attend.md deleted file mode 100644 index 628df1f0a..000000000 --- a/.changeset/fifty-comics-attend.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/validate-messages': patch ---- - -fix(validate-messages): typo IsData message diff --git a/.changeset/four-avocados-confess.md b/.changeset/four-avocados-confess.md deleted file mode 100644 index 46a136368..000000000 --- a/.changeset/four-avocados-confess.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/form-core': patch ---- - -FormControl: allow a label-sr-only flag to provide visually hidden labels diff --git a/.changeset/green-ads-fold.md b/.changeset/green-ads-fold.md deleted file mode 100644 index 5437bd4c2..000000000 --- a/.changeset/green-ads-fold.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/form-core': patch ---- - -form-core: expose 'mimicUserInput' test-helper diff --git a/.changeset/green-rocks-rule.md b/.changeset/green-rocks-rule.md deleted file mode 100644 index 28ee9bd9c..000000000 --- a/.changeset/green-rocks-rule.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/core': patch ---- - -SlotMixin: support scoped elements diff --git a/.changeset/hip-buses-itch.md b/.changeset/hip-buses-itch.md deleted file mode 100644 index d20551882..000000000 --- a/.changeset/hip-buses-itch.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/tabs': patch ---- - -tabs: allow to be initialized withhout children diff --git a/.changeset/hot-jars-leave.md b/.changeset/hot-jars-leave.md deleted file mode 100644 index 8b61cd2bf..000000000 --- a/.changeset/hot-jars-leave.md +++ /dev/null @@ -1,43 +0,0 @@ ---- -'providence-analytics': minor -'publish-docs': minor -'remark-extend': minor -'rocket-preset-extend-lion-docs': minor -'@lion/accordion': minor -'@lion/button': minor -'@lion/calendar': minor -'@lion/checkbox-group': minor -'@lion/collapsible': minor -'@lion/combobox': minor -'@lion/core': minor -'@lion/dialog': minor -'@lion/fieldset': minor -'@lion/form': minor -'@lion/form-core': minor -'@lion/form-integrations': minor -'@lion/icon': minor -'@lion/input': minor -'@lion/input-amount': minor -'@lion/input-date': minor -'@lion/input-datepicker': minor -'@lion/input-email': minor -'@lion/input-iban': minor -'@lion/input-range': minor -'@lion/input-stepper': minor -'@lion/listbox': minor -'@lion/localize': minor -'@lion/overlays': minor -'@lion/pagination': minor -'@lion/progress-indicator': minor -'@lion/radio-group': minor -'@lion/select': minor -'@lion/select-rich': minor -'@lion/steps': minor -'@lion/switch': minor -'@lion/tabs': minor -'@lion/textarea': minor -'@lion/tooltip': minor -'@lion/validate-messages': minor ---- - -New documentation structure diff --git a/.changeset/long-snails-complain.md b/.changeset/long-snails-complain.md deleted file mode 100644 index 64224fa41..000000000 --- a/.changeset/long-snails-complain.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/overlays': patch ---- - -Fix check for css typed object support diff --git a/.changeset/proud-geese-suffer.md b/.changeset/proud-geese-suffer.md deleted file mode 100644 index 4e373eac9..000000000 --- a/.changeset/proud-geese-suffer.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/form-core': minor ---- - -Validation: allow enums as outcome of a Validator diff --git a/.changeset/rare-panthers-crash.md b/.changeset/rare-panthers-crash.md deleted file mode 100644 index 732c593b1..000000000 --- a/.changeset/rare-panthers-crash.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/input-tel': minor ---- - -New component "LionInputTel" diff --git a/.changeset/real-yaks-float.md b/.changeset/real-yaks-float.md deleted file mode 100644 index e35a3837e..000000000 --- a/.changeset/real-yaks-float.md +++ /dev/null @@ -1,98 +0,0 @@ ---- -'@lion/core': minor -'@lion/form-core': minor -'@lion/listbox': minor -'@lion/select-rich': minor -'@lion/switch': minor -'@lion/accordion': minor -'@lion/ajax': minor -'@lion/button': minor -'@lion/calendar': minor -'@lion/checkbox-group': minor -'@lion/collapsible': minor -'@lion/combobox': minor -'@lion/dialog': minor -'@lion/fieldset': minor -'@lion/form': minor -'@lion/form-integrations': minor -'@lion/helpers': minor -'@lion/icon': minor -'@lion/input': minor -'@lion/input-amount': minor -'@lion/input-date': minor -'@lion/input-datepicker': minor -'@lion/input-email': minor -'@lion/input-iban': minor -'@lion/input-range': minor -'@lion/input-stepper': minor -'@lion/input-tel': minor -'@lion/input-tel-dropdown': minor -'@lion/localize': minor -'@lion/overlays': minor -'@lion/pagination': minor -'@lion/progress-indicator': minor -'@lion/radio-group': minor -'@lion/select': minor -'@lion/steps': minor -'@lion/tabs': minor -'@lion/textarea': minor -'@lion/tooltip': minor -'@lion/validate-messages': minor ---- - -BREAKING CHANGE: Work without polyfill if possible - -When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. -On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. - -To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. - -We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". -The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). - -To quote the release notes of `ScopedElementsMixin` v2.1.0: - -> ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. -> This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. - -And this was the case. - -With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. - -This essentially means the polyfill became optional which results in the following behavior - -1. If polyfill is not loaded it will use the global registry as a fallback -2. Log error if actually scoping is needed and polyfill is not loaded -3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now - -```diff -- const myButton = this.shadowRoot.createElement('my-button'); -+ const myButton = this.createScopedElement('my-button'); -``` - -This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. - -If you need scoping be sure to load the polyfill before any other web component gets registered. - -It may look something like this in your HTML - -```html - -``` - -or if you have an SPA you can load it at the top of your app shell code - -```js -import '@webcomponents/scoped-custom-element-registry'; -``` - -You need scoping if you want to - -use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) -or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) - -See more details at - -- [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) -- [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) -- [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) diff --git a/.changeset/red-oranges-nail.md b/.changeset/red-oranges-nail.md deleted file mode 100644 index a2a74095f..000000000 --- a/.changeset/red-oranges-nail.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/form-core': minor ---- - -Updated the ValidateMixin \_\_setupValidators method to sync the calendar date with validator params with reference to this issue : https://github.com/ing-bank/lion/pull/1641/files#diff-bed9319548b16e509dd4a5c3d9c7c31175b577f91e433ee55a945e05339d2796R632 diff --git a/.changeset/rude-cats-work.md b/.changeset/rude-cats-work.md deleted file mode 100644 index 1bc2166f9..000000000 --- a/.changeset/rude-cats-work.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'providence-analytics': patch ---- - -providence-analytics: expose skipCheckMatchCompatibility: skips semver checks when targets and reference projects are matched. Handy for forward compatible libs and libs below v1 diff --git a/.changeset/spicy-bikes-visit.md b/.changeset/spicy-bikes-visit.md deleted file mode 100644 index 1c7d6d711..000000000 --- a/.changeset/spicy-bikes-visit.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/validate-messages': patch ---- - -validate-messages: PhoneNumber messages diff --git a/.changeset/tame-moles-exist.md b/.changeset/tame-moles-exist.md deleted file mode 100644 index dba874621..000000000 --- a/.changeset/tame-moles-exist.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/input-datepicker': minor ---- - -Added a fix by overriding the \_\_onValidatorUpdated() to sync the calendar dates when the validator params got changed diff --git a/.changeset/tasty-socks-hammer.md b/.changeset/tasty-socks-hammer.md deleted file mode 100644 index 9b34f13a3..000000000 --- a/.changeset/tasty-socks-hammer.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/listbox': patch ---- - -Fix: Prevent default behavior while scrolling using arrow keys in a horizontal listbox diff --git a/.changeset/tender-rockets-vanish.md b/.changeset/tender-rockets-vanish.md deleted file mode 100644 index a531c3b28..000000000 --- a/.changeset/tender-rockets-vanish.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@lion/validate-messages': patch ---- - -Fixed en-PH default validation message diff --git a/.changeset/thirty-scissors-hug.md b/.changeset/thirty-scissors-hug.md deleted file mode 100644 index adefe266f..000000000 --- a/.changeset/thirty-scissors-hug.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'providence-analytics': patch ---- - -providence-analytics: enhanced allowlistMode detection diff --git a/packages-node/providence-analytics/CHANGELOG.md b/packages-node/providence-analytics/CHANGELOG.md index 74ab56833..947261409 100644 --- a/packages-node/providence-analytics/CHANGELOG.md +++ b/packages-node/providence-analytics/CHANGELOG.md @@ -1,5 +1,16 @@ # Change Log +## 0.13.0 + +### Minor Changes + +- 672c8e99: New documentation structure + +### Patch Changes + +- ab7cc1e0: providence-analytics: expose skipCheckMatchCompatibility: skips semver checks when targets and reference projects are matched. Handy for forward compatible libs and libs below v1 +- 17dadabf: providence-analytics: enhanced allowlistMode detection + ## 0.12.5 ### Patch Changes diff --git a/packages-node/providence-analytics/package.json b/packages-node/providence-analytics/package.json index eaf9bfc01..89f5c540c 100644 --- a/packages-node/providence-analytics/package.json +++ b/packages-node/providence-analytics/package.json @@ -1,6 +1,6 @@ { "name": "providence-analytics", - "version": "0.12.5", + "version": "0.13.0", "description": "Providence is the 'All Seeing Eye' that measures effectivity and popularity of software. Release management will become highly efficient due to an accurate impact analysis of (breaking) changes", "license": "MIT", "author": "ing-bank", diff --git a/packages-node/publish-docs/CHANGELOG.md b/packages-node/publish-docs/CHANGELOG.md index 172454e8c..54259a6a8 100644 --- a/packages-node/publish-docs/CHANGELOG.md +++ b/packages-node/publish-docs/CHANGELOG.md @@ -1,5 +1,11 @@ # publish-docs +## 0.2.0 + +### Minor Changes + +- 672c8e99: New documentation structure + ## 0.1.3 ### Patch Changes diff --git a/packages-node/publish-docs/package.json b/packages-node/publish-docs/package.json index ba26ce877..b2061cd58 100644 --- a/packages-node/publish-docs/package.json +++ b/packages-node/publish-docs/package.json @@ -1,6 +1,6 @@ { "name": "publish-docs", - "version": "0.1.3", + "version": "0.2.0", "description": "A tool that copies and processes your documentation (in a monorepo) so it can be published/shipped with your package.", "license": "MIT", "author": "ing-bank", diff --git a/packages-node/remark-extend/CHANGELOG.md b/packages-node/remark-extend/CHANGELOG.md index ce46cb955..dc2a73cb7 100644 --- a/packages-node/remark-extend/CHANGELOG.md +++ b/packages-node/remark-extend/CHANGELOG.md @@ -1,5 +1,11 @@ # Change Log +## 0.5.0 + +### Minor Changes + +- 672c8e99: New documentation structure + ## 0.4.4 ### Patch Changes diff --git a/packages-node/remark-extend/package.json b/packages-node/remark-extend/package.json index d9f326ab1..44000bf21 100644 --- a/packages-node/remark-extend/package.json +++ b/packages-node/remark-extend/package.json @@ -1,6 +1,6 @@ { "name": "remark-extend", - "version": "0.4.4", + "version": "0.5.0", "description": "A plugin for remark that allows to extend a md file with another md file", "license": "MIT", "author": "ing-bank", diff --git a/packages-node/rocket-preset-extend-lion-docs/CHANGELOG.md b/packages-node/rocket-preset-extend-lion-docs/CHANGELOG.md index 2d90bee82..61f0261fd 100644 --- a/packages-node/rocket-preset-extend-lion-docs/CHANGELOG.md +++ b/packages-node/rocket-preset-extend-lion-docs/CHANGELOG.md @@ -1,5 +1,16 @@ # rocket-preset-extend-lion-docs +## 0.3.0 + +### Minor Changes + +- 672c8e99: New documentation structure + +### Patch Changes + +- Updated dependencies [672c8e99] + - remark-extend@0.5.0 + ## 0.2.2 ### Patch Changes diff --git a/packages-node/rocket-preset-extend-lion-docs/package.json b/packages-node/rocket-preset-extend-lion-docs/package.json index f56ec6fd0..04128a7cc 100644 --- a/packages-node/rocket-preset-extend-lion-docs/package.json +++ b/packages-node/rocket-preset-extend-lion-docs/package.json @@ -1,6 +1,6 @@ { "name": "rocket-preset-extend-lion-docs", - "version": "0.2.2", + "version": "0.3.0", "description": "A rocket preset to reuse lion documentation inside your design system extension", "license": "MIT", "author": "ing-bank", @@ -32,7 +32,7 @@ "babel-plugin-extend-docs": "0.5.3", "es-module-lexer": "^0.3.6", "plugins-manager": "^0.3.0", - "remark-extend": "0.4.4", + "remark-extend": "0.5.0", "unist-util-visit": "^2.0.2" }, "keywords": [ diff --git a/packages/accordion/CHANGELOG.md b/packages/accordion/CHANGELOG.md index 7d16cac34..6c0c62198 100644 --- a/packages/accordion/CHANGELOG.md +++ b/packages/accordion/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.9.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.8.0 ### Minor Changes diff --git a/packages/accordion/package.json b/packages/accordion/package.json index 52497534b..ce2f48b53 100644 --- a/packages/accordion/package.json +++ b/packages/accordion/package.json @@ -1,6 +1,6 @@ { "name": "@lion/accordion", - "version": "0.8.0", + "version": "0.9.0", "description": "Vertically stacked list of invokers that can be clicked to reveal or hide content associated with them.", "license": "MIT", "author": "ing-bank", @@ -36,7 +36,7 @@ "lion-accordion.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "accordion", diff --git a/packages/ajax/CHANGELOG.md b/packages/ajax/CHANGELOG.md index 6d2e68df7..7c7e5e6aa 100644 --- a/packages/ajax/CHANGELOG.md +++ b/packages/ajax/CHANGELOG.md @@ -1,5 +1,66 @@ # Change Log +## 0.14.0 + +### Minor Changes + +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + ## 0.13.0 ### Minor Changes diff --git a/packages/ajax/package.json b/packages/ajax/package.json index f9dff8034..b761a4c1d 100644 --- a/packages/ajax/package.json +++ b/packages/ajax/package.json @@ -1,6 +1,6 @@ { "name": "@lion/ajax", - "version": "0.13.0", + "version": "0.14.0", "description": "Thin wrapper around fetch with support for interceptors.", "license": "MIT", "author": "ing-bank", diff --git a/packages/button/CHANGELOG.md b/packages/button/CHANGELOG.md index f68389b5b..18c1b46f8 100644 --- a/packages/button/CHANGELOG.md +++ b/packages/button/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.17.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.16.0 ### Minor Changes diff --git a/packages/button/package.json b/packages/button/package.json index 7964b0519..ba3e4cc5b 100644 --- a/packages/button/package.json +++ b/packages/button/package.json @@ -1,6 +1,6 @@ { "name": "@lion/button", - "version": "0.16.0", + "version": "0.17.0", "description": "A button that is easily styleable and accessible in all contexts", "license": "MIT", "author": "ing-bank", @@ -39,7 +39,7 @@ "define.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "button", diff --git a/packages/calendar/CHANGELOG.md b/packages/calendar/CHANGELOG.md index e281acbf8..98021dd11 100644 --- a/packages/calendar/CHANGELOG.md +++ b/packages/calendar/CHANGELOG.md @@ -1,5 +1,75 @@ # Change Log +## 0.19.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/localize@0.24.0 + ## 0.18.0 ### Minor Changes diff --git a/packages/calendar/package.json b/packages/calendar/package.json index 09adf1017..f32e29821 100644 --- a/packages/calendar/package.json +++ b/packages/calendar/package.json @@ -1,6 +1,6 @@ { "name": "@lion/calendar", - "version": "0.18.0", + "version": "0.19.0", "description": "Standalone calendar", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-calendar.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/localize": "^0.23.0" + "@lion/core": "^0.22.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "calendar", diff --git a/packages/checkbox-group/CHANGELOG.md b/packages/checkbox-group/CHANGELOG.md index c5e544122..3bd45088b 100644 --- a/packages/checkbox-group/CHANGELOG.md +++ b/packages/checkbox-group/CHANGELOG.md @@ -1,5 +1,80 @@ # Change Log +## 0.20.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + ## 0.19.0 ### Minor Changes diff --git a/packages/checkbox-group/package.json b/packages/checkbox-group/package.json index f197d2446..3011c17d6 100644 --- a/packages/checkbox-group/package.json +++ b/packages/checkbox-group/package.json @@ -1,6 +1,6 @@ { "name": "@lion/checkbox-group", - "version": "0.19.0", + "version": "0.20.0", "description": "A container for multiple checkboxes", "license": "MIT", "author": "ing-bank", @@ -39,9 +39,9 @@ "lion-checkbox-indeterminate.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0" }, "keywords": [ "checkbox-group", diff --git a/packages/collapsible/CHANGELOG.md b/packages/collapsible/CHANGELOG.md index e1aaede14..e29658742 100644 --- a/packages/collapsible/CHANGELOG.md +++ b/packages/collapsible/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.8.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.7.0 ### Minor Changes diff --git a/packages/collapsible/package.json b/packages/collapsible/package.json index a843ad71f..15fd7de9c 100644 --- a/packages/collapsible/package.json +++ b/packages/collapsible/package.json @@ -1,6 +1,6 @@ { "name": "@lion/collapsible", - "version": "0.7.0", + "version": "0.8.0", "description": "This component is a combination of a button (the invoker), a chunk of extra content.", "license": "MIT", "author": "ing-bank", @@ -38,7 +38,7 @@ "demo/custom-collapsible.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "collapsible", diff --git a/packages/combobox/CHANGELOG.md b/packages/combobox/CHANGELOG.md index 9e7036f8d..677d6b197 100644 --- a/packages/combobox/CHANGELOG.md +++ b/packages/combobox/CHANGELOG.md @@ -1,5 +1,83 @@ # Change Log +## 0.10.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [d46b9894] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [1ea9f291] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/listbox@0.13.0 + - @lion/overlays@0.32.0 + ## 0.9.0 ### Minor Changes diff --git a/packages/combobox/package.json b/packages/combobox/package.json index 56e5302ca..254780506 100644 --- a/packages/combobox/package.json +++ b/packages/combobox/package.json @@ -1,6 +1,6 @@ { "name": "@lion/combobox", - "version": "0.9.0", + "version": "0.10.0", "description": "A widget made up of a single-line textbox and an associated pop-up listbox element", "license": "MIT", "author": "ing-bank", @@ -45,10 +45,10 @@ "docs/google-combobox/google-combobox.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/listbox": "^0.12.0", - "@lion/overlays": "^0.31.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/listbox": "^0.13.0", + "@lion/overlays": "^0.32.0" }, "keywords": [ "combobox", diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md index f88b62e49..0660f6e81 100644 --- a/packages/core/CHANGELOG.md +++ b/packages/core/CHANGELOG.md @@ -1,5 +1,71 @@ # Change Log +## 0.22.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- 66531e3c: SlotMixin: support scoped elements + ## 0.21.1 ### Patch Changes diff --git a/packages/core/package.json b/packages/core/package.json index 19eb34d95..82b4682b5 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -1,6 +1,6 @@ { "name": "@lion/core", - "version": "0.21.1", + "version": "0.22.0", "description": "Core functionality that is shared across all Lion Web Components", "license": "MIT", "author": "ing-bank", diff --git a/packages/dialog/CHANGELOG.md b/packages/dialog/CHANGELOG.md index 2e61dbc97..979920ae7 100644 --- a/packages/dialog/CHANGELOG.md +++ b/packages/dialog/CHANGELOG.md @@ -1,5 +1,76 @@ # Change Log +## 0.15.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [d46b9894] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/overlays@0.32.0 + ## 0.14.0 ### Minor Changes diff --git a/packages/dialog/package.json b/packages/dialog/package.json index c8b530b72..848255529 100644 --- a/packages/dialog/package.json +++ b/packages/dialog/package.json @@ -1,6 +1,6 @@ { "name": "@lion/dialog", - "version": "0.14.0", + "version": "0.15.0", "description": "Show relative overlay content on click, as a webcomponent", "license": "MIT", "author": "ing-bank", @@ -37,8 +37,8 @@ "./docs/styled-dialog-content.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/overlays": "^0.31.0" + "@lion/core": "^0.22.0", + "@lion/overlays": "^0.32.0" }, "keywords": [ "dialog", diff --git a/packages/fieldset/CHANGELOG.md b/packages/fieldset/CHANGELOG.md index 19b262b34..b0c29800c 100644 --- a/packages/fieldset/CHANGELOG.md +++ b/packages/fieldset/CHANGELOG.md @@ -1,5 +1,79 @@ # Change Log +## 0.21.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + ## 0.20.0 ### Minor Changes diff --git a/packages/fieldset/package.json b/packages/fieldset/package.json index 76ccc0b2e..32edfa1cc 100644 --- a/packages/fieldset/package.json +++ b/packages/fieldset/package.json @@ -1,6 +1,6 @@ { "name": "@lion/fieldset", - "version": "0.20.0", + "version": "0.21.0", "description": "Allows to groups multiple input fields or other fieldsets together", "license": "MIT", "author": "ing-bank", @@ -37,8 +37,8 @@ "./docs/helpers/demo-fieldset-child.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0" }, "keywords": [ "fieldset", diff --git a/packages/form-core/CHANGELOG.md b/packages/form-core/CHANGELOG.md index a6482ddb8..3fee30208 100644 --- a/packages/form-core/CHANGELOG.md +++ b/packages/form-core/CHANGELOG.md @@ -1,5 +1,80 @@ # Change Log +## 0.17.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- 7016a150: Validation: allow enums as outcome of a Validator +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +- f408f6f8: Updated the ValidateMixin \_\_setupValidators method to sync the calendar date with validator params with reference to this issue : https://github.com/ing-bank/lion/pull/1641/files#diff-bed9319548b16e509dd4a5c3d9c7c31175b577f91e433ee55a945e05339d2796R632 + +### Patch Changes + +- 9c1dfdcd: FormControl: allow a label-sr-only flag to provide visually hidden labels +- 3772c943: form-core: expose 'mimicUserInput' test-helper +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/localize@0.24.0 + ## 0.16.0 ### Minor Changes diff --git a/packages/form-core/package.json b/packages/form-core/package.json index 2e2cb6a0f..11ff1d772 100644 --- a/packages/form-core/package.json +++ b/packages/form-core/package.json @@ -1,6 +1,6 @@ { "name": "@lion/form-core", - "version": "0.16.0", + "version": "0.17.0", "description": "Form-core contains all essential building blocks for creating form fields and fieldsets", "license": "MIT", "author": "ing-bank", @@ -38,8 +38,8 @@ "lion-validation-feedback.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/localize": "^0.23.0" + "@lion/core": "^0.22.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "field", diff --git a/packages/form-integrations/CHANGELOG.md b/packages/form-integrations/CHANGELOG.md index 47d9e3414..2443f02ce 100644 --- a/packages/form-integrations/CHANGELOG.md +++ b/packages/form-integrations/CHANGELOG.md @@ -1,5 +1,105 @@ # Change Log +## 0.11.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [998d95f9] +- Updated dependencies [1ea9f291] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/button@0.17.0 + - @lion/checkbox-group@0.20.0 + - @lion/combobox@0.10.0 + - @lion/fieldset@0.21.0 + - @lion/form@0.14.0 + - @lion/input@0.17.0 + - @lion/input-amount@0.16.0 + - @lion/input-date@0.14.0 + - @lion/input-datepicker@0.25.0 + - @lion/input-email@0.15.0 + - @lion/input-iban@0.18.0 + - @lion/input-range@0.12.0 + - @lion/input-stepper@0.8.0 + - @lion/listbox@0.13.0 + - @lion/localize@0.24.0 + - @lion/radio-group@0.20.0 + - @lion/select@0.16.0 + - @lion/select-rich@0.30.0 + - @lion/switch@0.20.0 + - @lion/textarea@0.15.0 + ## 0.10.0 ### Minor Changes diff --git a/packages/form-integrations/package.json b/packages/form-integrations/package.json index 4d3259b2e..2d2d44806 100644 --- a/packages/form-integrations/package.json +++ b/packages/form-integrations/package.json @@ -1,6 +1,6 @@ { "name": "@lion/form-integrations", - "version": "0.10.0", + "version": "0.11.0", "description": "The Form System allows you to create complex forms with various validation in an easy way", "license": "MIT", "author": "ing-bank", @@ -32,29 +32,29 @@ "test": "cd ../../ && npm run test:browser -- --group form-integrations" }, "dependencies": { - "@lion/button": "^0.16.0", - "@lion/checkbox-group": "^0.19.0", - "@lion/combobox": "^0.9.0", - "@lion/core": "^0.21.0", - "@lion/fieldset": "^0.20.0", - "@lion/form": "^0.13.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0", - "@lion/input-amount": "^0.15.0", - "@lion/input-date": "^0.13.0", - "@lion/input-datepicker": "^0.24.0", - "@lion/input-email": "^0.14.0", - "@lion/input-iban": "^0.17.0", - "@lion/input-range": "^0.11.0", - "@lion/input-stepper": "^0.7.0", - "@lion/listbox": "^0.12.0", - "@lion/localize": "^0.23.0", - "@lion/radio-group": "^0.19.0", - "@lion/select": "^0.15.0", - "@lion/select-rich": "^0.29.0", - "@lion/switch": "^0.19.0", - "@lion/textarea": "^0.14.0", - "@lion/validate-messages": "^0.8.0" + "@lion/button": "^0.17.0", + "@lion/checkbox-group": "^0.20.0", + "@lion/combobox": "^0.10.0", + "@lion/core": "^0.22.0", + "@lion/fieldset": "^0.21.0", + "@lion/form": "^0.14.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0", + "@lion/input-amount": "^0.16.0", + "@lion/input-date": "^0.14.0", + "@lion/input-datepicker": "^0.25.0", + "@lion/input-email": "^0.15.0", + "@lion/input-iban": "^0.18.0", + "@lion/input-range": "^0.12.0", + "@lion/input-stepper": "^0.8.0", + "@lion/listbox": "^0.13.0", + "@lion/localize": "^0.24.0", + "@lion/radio-group": "^0.20.0", + "@lion/select": "^0.16.0", + "@lion/select-rich": "^0.30.0", + "@lion/switch": "^0.20.0", + "@lion/textarea": "^0.15.0", + "@lion/validate-messages": "^0.9.0" }, "keywords": [ "form", diff --git a/packages/form/CHANGELOG.md b/packages/form/CHANGELOG.md index 89d30b0ce..5e0ec609f 100644 --- a/packages/form/CHANGELOG.md +++ b/packages/form/CHANGELOG.md @@ -1,5 +1,73 @@ # Change Log +## 0.14.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/fieldset@0.21.0 + ## 0.13.0 ### Minor Changes diff --git a/packages/form/package.json b/packages/form/package.json index 18cf9c09d..c9d8ac8cf 100644 --- a/packages/form/package.json +++ b/packages/form/package.json @@ -1,6 +1,6 @@ { "name": "@lion/form", - "version": "0.13.0", + "version": "0.14.0", "description": "It enhances the functionality of the native `form` component. It is designed to interact with (instances of) form fields", "license": "MIT", "author": "ing-bank", @@ -36,7 +36,7 @@ "lion-form.js" ], "dependencies": { - "@lion/fieldset": "^0.20.0" + "@lion/fieldset": "^0.21.0" }, "keywords": [ "form", diff --git a/packages/helpers/CHANGELOG.md b/packages/helpers/CHANGELOG.md index 9b8d229dd..9da0124cf 100644 --- a/packages/helpers/CHANGELOG.md +++ b/packages/helpers/CHANGELOG.md @@ -1,5 +1,73 @@ # Change Log +## 0.11.0 + +### Minor Changes + +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.10.0 ### Minor Changes diff --git a/packages/helpers/package.json b/packages/helpers/package.json index 20dc84b2a..472d94b75 100644 --- a/packages/helpers/package.json +++ b/packages/helpers/package.json @@ -1,6 +1,6 @@ { "name": "@lion/helpers", - "version": "0.10.0", + "version": "0.11.0", "description": "Helpers that are used throughout lion and can be used outside", "license": "MIT", "author": "ing-bank", @@ -35,7 +35,7 @@ "sb-locale-switcher.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "action logger", diff --git a/packages/icon/CHANGELOG.md b/packages/icon/CHANGELOG.md index cba55cbfd..c76186ac1 100644 --- a/packages/icon/CHANGELOG.md +++ b/packages/icon/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.15.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.14.0 ### Minor Changes diff --git a/packages/icon/package.json b/packages/icon/package.json index 3dff625b1..21057f6e0 100644 --- a/packages/icon/package.json +++ b/packages/icon/package.json @@ -1,6 +1,6 @@ { "name": "@lion/icon", - "version": "0.14.0", + "version": "0.15.0", "description": "A web component easily displaying svg icons", "license": "MIT", "author": "ing-bank", @@ -37,7 +37,7 @@ "./docs/icon-resolvers.js" ], "dependencies": { - "@lion/core": "^0.21.0", + "@lion/core": "^0.22.0", "singleton-manager": "^1.4.3" }, "keywords": [ diff --git a/packages/input-amount/CHANGELOG.md b/packages/input-amount/CHANGELOG.md index 58c928240..278692d13 100644 --- a/packages/input-amount/CHANGELOG.md +++ b/packages/input-amount/CHANGELOG.md @@ -1,5 +1,85 @@ # Change Log +## 0.16.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 + ## 0.15.0 ### Minor Changes diff --git a/packages/input-amount/package.json b/packages/input-amount/package.json index 425f64f3a..8505f03e0 100644 --- a/packages/input-amount/package.json +++ b/packages/input-amount/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-amount", - "version": "0.15.0", + "version": "0.16.0", "description": "Provide a way for users to fill in an amount", "license": "MIT", "author": "ing-bank", @@ -36,11 +36,11 @@ "lion-input-amount.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0", - "@lion/localize": "^0.23.0", - "@lion/validate-messages": "^0.8.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0", + "@lion/localize": "^0.24.0", + "@lion/validate-messages": "^0.9.0" }, "keywords": [ "input-amount", diff --git a/packages/input-date/CHANGELOG.md b/packages/input-date/CHANGELOG.md index b6ec3bbbd..c5b3d36db 100644 --- a/packages/input-date/CHANGELOG.md +++ b/packages/input-date/CHANGELOG.md @@ -1,5 +1,85 @@ # Change Log +## 0.14.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 + ## 0.13.0 ### Minor Changes diff --git a/packages/input-date/package.json b/packages/input-date/package.json index 3ce5a20d4..9858f512f 100644 --- a/packages/input-date/package.json +++ b/packages/input-date/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-date", - "version": "0.13.0", + "version": "0.14.0", "description": "Provide a way for users to fill in a date", "license": "MIT", "author": "ing-bank", @@ -36,11 +36,11 @@ "lion-input-date.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0", - "@lion/localize": "^0.23.0", - "@lion/validate-messages": "^0.8.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0", + "@lion/localize": "^0.24.0", + "@lion/validate-messages": "^0.9.0" }, "keywords": [ "input-date", diff --git a/packages/input-datepicker/CHANGELOG.md b/packages/input-datepicker/CHANGELOG.md index 67a4942b3..732bb98ed 100644 --- a/packages/input-datepicker/CHANGELOG.md +++ b/packages/input-datepicker/CHANGELOG.md @@ -1,5 +1,90 @@ # Change Log +## 0.25.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +- 998d95f9: Added a fix by overriding the \_\_onValidatorUpdated() to sync the calendar dates when the validator params got changed + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [d46b9894] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/calendar@0.19.0 + - @lion/input-date@0.14.0 + - @lion/localize@0.24.0 + - @lion/overlays@0.32.0 + ## 0.24.0 ### Minor Changes diff --git a/packages/input-datepicker/package.json b/packages/input-datepicker/package.json index 2ff77db10..801d23dfc 100644 --- a/packages/input-datepicker/package.json +++ b/packages/input-datepicker/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-datepicker", - "version": "0.24.0", + "version": "0.25.0", "description": "Provide a way for users to fill in a date via a calendar overlay", "license": "MIT", "author": "ing-bank", @@ -36,13 +36,13 @@ "lion-input-datepicker.js" ], "dependencies": { - "@lion/calendar": "^0.18.0", - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input-date": "^0.13.0", - "@lion/localize": "^0.23.0", - "@lion/overlays": "^0.31.0", - "@lion/validate-messages": "^0.8.0" + "@lion/calendar": "^0.19.0", + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input-date": "^0.14.0", + "@lion/localize": "^0.24.0", + "@lion/overlays": "^0.32.0", + "@lion/validate-messages": "^0.9.0" }, "keywords": [ "calendar", diff --git a/packages/input-email/CHANGELOG.md b/packages/input-email/CHANGELOG.md index c7dfaf028..de066accf 100644 --- a/packages/input-email/CHANGELOG.md +++ b/packages/input-email/CHANGELOG.md @@ -1,5 +1,85 @@ # Change Log +## 0.15.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 + ## 0.14.0 ### Minor Changes diff --git a/packages/input-email/package.json b/packages/input-email/package.json index 03925c827..785f2f369 100644 --- a/packages/input-email/package.json +++ b/packages/input-email/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-email", - "version": "0.14.0", + "version": "0.15.0", "description": "Provide a way for users to fill in an email", "license": "MIT", "author": "ing-bank", @@ -36,11 +36,11 @@ "lion-input-email.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0", - "@lion/localize": "^0.23.0", - "@lion/validate-messages": "^0.8.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0", + "@lion/localize": "^0.24.0", + "@lion/validate-messages": "^0.9.0" }, "keywords": [ "input-email", diff --git a/packages/input-iban/CHANGELOG.md b/packages/input-iban/CHANGELOG.md index 7f028485d..37ae7fc51 100644 --- a/packages/input-iban/CHANGELOG.md +++ b/packages/input-iban/CHANGELOG.md @@ -1,5 +1,85 @@ # Change Log +## 0.18.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [a64c552b] +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [f7df1ae8] +- Updated dependencies [85318e3b] + - @lion/validate-messages@0.9.0 + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 + ## 0.17.0 ### Minor Changes diff --git a/packages/input-iban/package.json b/packages/input-iban/package.json index 3fd863d8c..4983c231d 100644 --- a/packages/input-iban/package.json +++ b/packages/input-iban/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-iban", - "version": "0.17.0", + "version": "0.18.0", "description": "Provide a way for users to fill in an iban", "license": "MIT", "author": "ing-bank", @@ -36,11 +36,11 @@ "lion-input-iban.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0", - "@lion/localize": "^0.23.0", - "@lion/validate-messages": "^0.8.0", + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0", + "@lion/localize": "^0.24.0", + "@lion/validate-messages": "^0.9.0", "ibantools": "^2.2.0" }, "keywords": [ diff --git a/packages/input-range/CHANGELOG.md b/packages/input-range/CHANGELOG.md index 0db655492..73d3560dd 100644 --- a/packages/input-range/CHANGELOG.md +++ b/packages/input-range/CHANGELOG.md @@ -1,5 +1,76 @@ # Change Log +## 0.12.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 + ## 0.11.1 ### Patch Changes diff --git a/packages/input-range/package.json b/packages/input-range/package.json index ab5c3060d..ec49dcc29 100644 --- a/packages/input-range/package.json +++ b/packages/input-range/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-range", - "version": "0.11.1", + "version": "0.12.0", "description": "Provide a way for users to select one value from a range of values", "license": "MIT", "author": "ing-bank", @@ -36,9 +36,9 @@ "lion-input-range.js" ], "dependencies": { - "@lion/core": "^0.21.1", - "@lion/input": "^0.16.0", - "@lion/localize": "^0.23.0" + "@lion/core": "^0.22.0", + "@lion/input": "^0.17.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "input-range", diff --git a/packages/input-stepper/CHANGELOG.md b/packages/input-stepper/CHANGELOG.md index c7eff9eaa..1c4cc1e38 100644 --- a/packages/input-stepper/CHANGELOG.md +++ b/packages/input-stepper/CHANGELOG.md @@ -1,5 +1,80 @@ # Change Log +## 0.8.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + ## 0.7.0 ### Minor Changes diff --git a/packages/input-stepper/package.json b/packages/input-stepper/package.json index ce0a29988..853ef53f7 100644 --- a/packages/input-stepper/package.json +++ b/packages/input-stepper/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-stepper", - "version": "0.7.0", + "version": "0.8.0", "description": "This component enables the user to increase and decrease a numeric value by predefined range.", "license": "MIT", "author": "ing-bank", @@ -36,9 +36,9 @@ "lion-input-stepper.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0" }, "keywords": [ "input", diff --git a/packages/input-tel-dropdown/CHANGELOG.md b/packages/input-tel-dropdown/CHANGELOG.md new file mode 100644 index 000000000..ef8ac65c3 --- /dev/null +++ b/packages/input-tel-dropdown/CHANGELOG.md @@ -0,0 +1,72 @@ +# @lion/input-tel-dropdown + +## 0.1.0 +### Minor Changes + +- 32b322c3: New component LionInpuTelDropdown +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [a882c94f] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/localize@0.24.0 + - @lion/input-tel@0.1.0 diff --git a/packages/input-tel-dropdown/package.json b/packages/input-tel-dropdown/package.json index 1a46eb423..9ecb17e7e 100644 --- a/packages/input-tel-dropdown/package.json +++ b/packages/input-tel-dropdown/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-tel-dropdown", - "version": "0.0.0", + "version": "0.1.0", "description": "Input field for entering phone numbers with the help of a dropdown region list", "license": "MIT", "author": "ing-bank", @@ -34,9 +34,9 @@ "lion-input-tel-dropdown.js" ], "dependencies": { - "@lion/core": "0.21.1", - "@lion/input-tel": "0.0.0", - "@lion/localize": "0.23.0" + "@lion/core": "0.22.0", + "@lion/input-tel": "0.1.0", + "@lion/localize": "0.24.0" }, "keywords": [ "input", diff --git a/packages/input-tel/CHANGELOG.md b/packages/input-tel/CHANGELOG.md new file mode 100644 index 000000000..8ce8ba5dd --- /dev/null +++ b/packages/input-tel/CHANGELOG.md @@ -0,0 +1,76 @@ +# @lion/input-tel + +## 0.1.0 +### Minor Changes + +- a882c94f: New component "LionInputTel" +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + - @lion/localize@0.24.0 diff --git a/packages/input-tel/package.json b/packages/input-tel/package.json index 4e268926d..14fabe728 100644 --- a/packages/input-tel/package.json +++ b/packages/input-tel/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input-tel", - "version": "0.0.0", + "version": "0.1.0", "description": "Input field for entering phone numbers, including validation, formatting and mobile keyboard support.", "license": "MIT", "author": "ing-bank", @@ -37,10 +37,10 @@ "lion-input-tel.js" ], "dependencies": { - "@lion/core": "0.21.1", - "@lion/form-core": "0.16.0", - "@lion/input": "0.16.0", - "@lion/localize": "0.23.0" + "@lion/core": "0.22.0", + "@lion/form-core": "0.17.0", + "@lion/input": "0.17.0", + "@lion/localize": "0.24.0" }, "keywords": [ "input", diff --git a/packages/input/CHANGELOG.md b/packages/input/CHANGELOG.md index 1b81114cc..96a5d443e 100644 --- a/packages/input/CHANGELOG.md +++ b/packages/input/CHANGELOG.md @@ -1,5 +1,77 @@ # Change Log +## 0.17.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + ## 0.16.0 ### Minor Changes diff --git a/packages/input/package.json b/packages/input/package.json index f7cf2c580..581121faa 100644 --- a/packages/input/package.json +++ b/packages/input/package.json @@ -1,6 +1,6 @@ { "name": "@lion/input", - "version": "0.16.0", + "version": "0.17.0", "description": "It enhances the functionality of the native `` element", "license": "MIT", "author": "ing-bank", @@ -36,7 +36,7 @@ "lion-input.js" ], "dependencies": { - "@lion/form-core": "^0.16.0" + "@lion/form-core": "^0.17.0" }, "keywords": [ "input", diff --git a/packages/listbox/CHANGELOG.md b/packages/listbox/CHANGELOG.md index 5e236670a..2e7f526bc 100644 --- a/packages/listbox/CHANGELOG.md +++ b/packages/listbox/CHANGELOG.md @@ -1,5 +1,80 @@ # @lion/listbox +## 0.13.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- 1ea9f291: Fix: Prevent default behavior while scrolling using arrow keys in a horizontal listbox +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + ## 0.12.0 ### Minor Changes diff --git a/packages/listbox/package.json b/packages/listbox/package.json index 8ba7af169..5da78f1e9 100644 --- a/packages/listbox/package.json +++ b/packages/listbox/package.json @@ -1,6 +1,6 @@ { "name": "@lion/listbox", - "version": "0.12.0", + "version": "0.13.0", "description": "A listbox widget presents a list of options and allows a user to select one or more of them", "license": "MIT", "author": "ing-bank", @@ -39,8 +39,8 @@ "lion-options.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0" }, "keywords": [ "form", diff --git a/packages/localize/CHANGELOG.md b/packages/localize/CHANGELOG.md index 32ab85222..8b7e625f2 100644 --- a/packages/localize/CHANGELOG.md +++ b/packages/localize/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.24.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.23.0 ### Minor Changes diff --git a/packages/localize/package.json b/packages/localize/package.json index 81a835df8..5fac816b3 100644 --- a/packages/localize/package.json +++ b/packages/localize/package.json @@ -1,6 +1,6 @@ { "name": "@lion/localize", - "version": "0.23.0", + "version": "0.24.0", "description": "The localization system helps to manage localization data split into locales and automate its loading", "license": "MIT", "author": "ing-bank", @@ -34,7 +34,7 @@ "sideEffects": false, "dependencies": { "@bundled-es-modules/message-format": "6.0.4", - "@lion/core": "^0.21.0", + "@lion/core": "^0.22.0", "singleton-manager": "^1.4.3" }, "keywords": [ diff --git a/packages/overlays/CHANGELOG.md b/packages/overlays/CHANGELOG.md index e566985ac..72f1af5de 100644 --- a/packages/overlays/CHANGELOG.md +++ b/packages/overlays/CHANGELOG.md @@ -1,5 +1,75 @@ # Change Log +## 0.32.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- d46b9894: Fix check for css typed object support +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.31.0 ### Minor Changes diff --git a/packages/overlays/package.json b/packages/overlays/package.json index 56dea6a60..ab2b27ae9 100644 --- a/packages/overlays/package.json +++ b/packages/overlays/package.json @@ -1,6 +1,6 @@ { "name": "@lion/overlays", - "version": "0.31.0", + "version": "0.32.0", "description": "Overlays System using lit-html for rendering", "license": "MIT", "author": "ing-bank", @@ -37,7 +37,7 @@ "./docs/applyDemoOverlayStyles.js" ], "dependencies": { - "@lion/core": "^0.21.0", + "@lion/core": "^0.22.0", "@popperjs/core": "^2.5.4", "singleton-manager": "^1.4.3" }, diff --git a/packages/pagination/CHANGELOG.md b/packages/pagination/CHANGELOG.md index 3714078cf..e357a73f6 100644 --- a/packages/pagination/CHANGELOG.md +++ b/packages/pagination/CHANGELOG.md @@ -1,5 +1,75 @@ # Change Log +## 0.8.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/localize@0.24.0 + ## 0.7.0 ### Minor Changes diff --git a/packages/pagination/package.json b/packages/pagination/package.json index 31763bf61..7fecdceae 100644 --- a/packages/pagination/package.json +++ b/packages/pagination/package.json @@ -1,6 +1,6 @@ { "name": "@lion/pagination", - "version": "0.7.0", + "version": "0.8.0", "description": "A component that handles pagination.", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-pagination.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/localize": "^0.23.0" + "@lion/core": "^0.22.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "lion", diff --git a/packages/progress-indicator/CHANGELOG.md b/packages/progress-indicator/CHANGELOG.md index c8a7534a2..5c6b8dae8 100644 --- a/packages/progress-indicator/CHANGELOG.md +++ b/packages/progress-indicator/CHANGELOG.md @@ -1,5 +1,75 @@ # @lion/progress-indicator +## 0.8.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/localize@0.24.0 + ## 0.7.0 ### Minor Changes diff --git a/packages/progress-indicator/package.json b/packages/progress-indicator/package.json index a54717919..ec6e0e714 100644 --- a/packages/progress-indicator/package.json +++ b/packages/progress-indicator/package.json @@ -1,6 +1,6 @@ { "name": "@lion/progress-indicator", - "version": "0.7.0", + "version": "0.8.0", "description": "A progress indicator that is easily styleable and accessible in all contexts", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-progress-indicator.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/localize": "^0.23.0" + "@lion/core": "^0.22.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "lion", diff --git a/packages/radio-group/CHANGELOG.md b/packages/radio-group/CHANGELOG.md index 946aebfaf..d97a9dfdc 100644 --- a/packages/radio-group/CHANGELOG.md +++ b/packages/radio-group/CHANGELOG.md @@ -1,5 +1,80 @@ # Change Log +## 0.20.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/input@0.17.0 + ## 0.19.0 ### Minor Changes diff --git a/packages/radio-group/package.json b/packages/radio-group/package.json index b5601d756..bae034e9e 100644 --- a/packages/radio-group/package.json +++ b/packages/radio-group/package.json @@ -1,6 +1,6 @@ { "name": "@lion/radio-group", - "version": "0.19.0", + "version": "0.20.0", "description": "Manage a group of choices", "license": "MIT", "author": "ing-bank", @@ -38,9 +38,9 @@ "lion-radio-group.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/input": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/input": "^0.17.0" }, "keywords": [ "lion", diff --git a/packages/select-rich/CHANGELOG.md b/packages/select-rich/CHANGELOG.md index b75ff16e3..bcdf12803 100644 --- a/packages/select-rich/CHANGELOG.md +++ b/packages/select-rich/CHANGELOG.md @@ -1,5 +1,84 @@ # Change Log +## 0.30.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [d46b9894] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] +- Updated dependencies [1ea9f291] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/button@0.17.0 + - @lion/listbox@0.13.0 + - @lion/overlays@0.32.0 + ## 0.29.0 ### Minor Changes diff --git a/packages/select-rich/package.json b/packages/select-rich/package.json index 453549c1d..4bb2ee061 100644 --- a/packages/select-rich/package.json +++ b/packages/select-rich/package.json @@ -1,6 +1,6 @@ { "name": "@lion/select-rich", - "version": "0.29.0", + "version": "0.30.0", "description": "Provides a select with options that can contain html", "license": "MIT", "author": "ing-bank", @@ -40,11 +40,11 @@ "lion-select-rich.js" ], "dependencies": { - "@lion/button": "^0.16.0", - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/listbox": "^0.12.0", - "@lion/overlays": "^0.31.0" + "@lion/button": "^0.17.0", + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/listbox": "^0.13.0", + "@lion/overlays": "^0.32.0" }, "keywords": [ "field", diff --git a/packages/select/CHANGELOG.md b/packages/select/CHANGELOG.md index f0df378ab..e4601f398 100644 --- a/packages/select/CHANGELOG.md +++ b/packages/select/CHANGELOG.md @@ -1,5 +1,79 @@ # Change Log +## 0.16.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + ## 0.15.0 ### Minor Changes diff --git a/packages/select/package.json b/packages/select/package.json index 26b69a1ba..a31b4eaa4 100644 --- a/packages/select/package.json +++ b/packages/select/package.json @@ -1,6 +1,6 @@ { "name": "@lion/select", - "version": "0.15.0", + "version": "0.16.0", "description": "Provide a set of options where you can select one", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-select.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0" }, "keywords": [ "lion", diff --git a/packages/steps/CHANGELOG.md b/packages/steps/CHANGELOG.md index dfb5d352b..a631a91ed 100644 --- a/packages/steps/CHANGELOG.md +++ b/packages/steps/CHANGELOG.md @@ -1,5 +1,74 @@ # Change Log +## 0.11.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.10.0 ### Minor Changes diff --git a/packages/steps/package.json b/packages/steps/package.json index 43a59918b..1ee3c6f8b 100644 --- a/packages/steps/package.json +++ b/packages/steps/package.json @@ -1,6 +1,6 @@ { "name": "@lion/steps", - "version": "0.10.0", + "version": "0.11.0", "description": "Breaks a single goal down into dependable sub-tasks.", "license": "MIT", "author": "ing-bank", @@ -38,7 +38,7 @@ "lion-steps.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "lion", diff --git a/packages/switch/CHANGELOG.md b/packages/switch/CHANGELOG.md index 9b8b930eb..8058c3dd5 100644 --- a/packages/switch/CHANGELOG.md +++ b/packages/switch/CHANGELOG.md @@ -1,5 +1,80 @@ # Change Log +## 0.20.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + - @lion/helpers@0.11.0 + ## 0.19.0 ### Minor Changes diff --git a/packages/switch/package.json b/packages/switch/package.json index 04b6c7491..bba8eb3cc 100644 --- a/packages/switch/package.json +++ b/packages/switch/package.json @@ -1,6 +1,6 @@ { "name": "@lion/switch", - "version": "0.19.0", + "version": "0.20.0", "description": "A Switch is used for switching a property or feature on and off", "license": "MIT", "author": "ing-bank", @@ -38,9 +38,9 @@ "lion-switch-button.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", - "@lion/helpers": "^0.10.0" + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", + "@lion/helpers": "^0.11.0" }, "keywords": [ "lion", diff --git a/packages/tabs/CHANGELOG.md b/packages/tabs/CHANGELOG.md index 5706afe5f..36ec88670 100644 --- a/packages/tabs/CHANGELOG.md +++ b/packages/tabs/CHANGELOG.md @@ -1,5 +1,75 @@ # Change Log +## 0.12.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- 03c294c9: tabs: allow to be initialized withhout children +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + ## 0.11.0 ### Minor Changes diff --git a/packages/tabs/package.json b/packages/tabs/package.json index 2095b1300..b11dd7ac3 100644 --- a/packages/tabs/package.json +++ b/packages/tabs/package.json @@ -1,6 +1,6 @@ { "name": "@lion/tabs", - "version": "0.11.0", + "version": "0.12.0", "description": "Allows users to quickly move between a small number of equally important views.", "license": "MIT", "author": "ing-bank", @@ -36,7 +36,7 @@ "lion-tabs.js" ], "dependencies": { - "@lion/core": "^0.21.0" + "@lion/core": "^0.22.0" }, "keywords": [ "lion", diff --git a/packages/textarea/CHANGELOG.md b/packages/textarea/CHANGELOG.md index f85956490..681fae497 100644 --- a/packages/textarea/CHANGELOG.md +++ b/packages/textarea/CHANGELOG.md @@ -1,5 +1,79 @@ # Change Log +## 0.15.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/core@0.22.0 + ## 0.14.0 ### Minor Changes diff --git a/packages/textarea/package.json b/packages/textarea/package.json index 15e27d008..a3369bd82 100644 --- a/packages/textarea/package.json +++ b/packages/textarea/package.json @@ -1,6 +1,6 @@ { "name": "@lion/textarea", - "version": "0.14.0", + "version": "0.15.0", "description": "Provide a way for users to write text that is multiple lines long", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-textarea.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/form-core": "^0.16.0", + "@lion/core": "^0.22.0", + "@lion/form-core": "^0.17.0", "@types/autosize": "^3.0.7", "autosize": "4.0.2" }, diff --git a/packages/tooltip/CHANGELOG.md b/packages/tooltip/CHANGELOG.md index 2ab7cb4b3..7fc5151ea 100644 --- a/packages/tooltip/CHANGELOG.md +++ b/packages/tooltip/CHANGELOG.md @@ -1,5 +1,76 @@ # Change Log +## 0.23.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- Updated dependencies [66531e3c] +- Updated dependencies [672c8e99] +- Updated dependencies [d46b9894] +- Updated dependencies [aa8b8916] + - @lion/core@0.22.0 + - @lion/overlays@0.32.0 + ## 0.22.0 ### Minor Changes diff --git a/packages/tooltip/package.json b/packages/tooltip/package.json index df7624a9a..2a8fbd063 100644 --- a/packages/tooltip/package.json +++ b/packages/tooltip/package.json @@ -1,6 +1,6 @@ { "name": "@lion/tooltip", - "version": "0.22.0", + "version": "0.23.0", "description": "Show relative overlay content on hover", "license": "MIT", "author": "ing-bank", @@ -36,8 +36,8 @@ "lion-tooltip.js" ], "dependencies": { - "@lion/core": "^0.21.0", - "@lion/overlays": "^0.31.0" + "@lion/core": "^0.22.0", + "@lion/overlays": "^0.32.0" }, "keywords": [ "lion", diff --git a/packages/validate-messages/CHANGELOG.md b/packages/validate-messages/CHANGELOG.md index 9b34feaac..2c6b0ae3e 100644 --- a/packages/validate-messages/CHANGELOG.md +++ b/packages/validate-messages/CHANGELOG.md @@ -1,5 +1,83 @@ # Change Log +## 0.9.0 + +### Minor Changes + +- 672c8e99: New documentation structure +- aa8b8916: BREAKING CHANGE: Work without polyfill if possible + + When using [component composition](https://lit.dev/docs/composition/component-composition/) in a Lion Component we always made it very explicit which sub-components are used. + On top of that we scoped these [sub components](https://open-wc.org/docs/development/scoped-elements/) to the [current shadow root](https://github.com/WICG/webcomponents/blob/gh-pages/proposals/Scoped-Custom-Element-Registries.md) allowing multiple version to be used simultaneously. + + To enable this features we relied on the fact that the `ScopedElementsMixin` did loaded the needed polyfill for us. + + We however over time got feedback from multiple consumers that lion components "break the app as soon as you load them". + The reasons is/was that not everyone is always using `ScopedElementsMixin` or in full control of the app (or its load order). + + To quote the release notes of `ScopedElementsMixin` v2.1.0: + + > ScopedElementsMixin 2.x tried to be as convenient as possible by automatically loading the scoped custom elements registry polyfill. + > This however led to a fatal error whenever you registered any component before ScopedElementsMixin was used. + + And this was the case. + + With the upgrade to `@open-wc/scoped-elements` v2.1.1 Lion now no longer automatically loads the polyfill through `ScopedElementsMixin`. + + This essentially means the polyfill became optional which results in the following behavior + + 1. If polyfill is not loaded it will use the global registry as a fallback + 2. Log error if actually scoping is needed and polyfill is not loaded + 3. If you manually create elements you will need to handle polyfilled and not polyfilled cases now + + ```diff + - const myButton = this.shadowRoot.createElement('my-button'); + + const myButton = this.createScopedElement('my-button'); + ``` + + This also removes `@webcomponents/scoped-custom-element-registry` as a production dependency. + + If you need scoping be sure to load the polyfill before any other web component gets registered. + + It may look something like this in your HTML + + ```html + + ``` + + or if you have an SPA you can load it at the top of your app shell code + + ```js + import '@webcomponents/scoped-custom-element-registry'; + ``` + + You need scoping if you want to + + use 2 major versions of a web component (e.g. in an SPA pageA uses 1.x and pageB uses 2.x of color-picker) + or you want to use the same tag name with different implementations (use tag color-picker from foo here and from bar here) + + See more details at + + - [Lion release blog post](https://lion-web.netlify.app/blog/lion-without-polyfills/) + - [@open-wc/scoped-elements release blog post](https://open-wc.org/blog/scoped-elements-without-polyfill/) + - [Change log of ScopedElementsMixin](https://github.com/open-wc/open-wc/blob/master/packages/scoped-elements/CHANGELOG.md#210) + +### Patch Changes + +- a64c552b: fix(validate-messages): typo IsData message +- f7df1ae8: validate-messages: PhoneNumber messages +- 85318e3b: Fixed en-PH default validation message +- Updated dependencies [9c1dfdcd] +- Updated dependencies [3772c943] +- Updated dependencies [672c8e99] +- Updated dependencies [7016a150] +- Updated dependencies [a882c94f] +- Updated dependencies [aa8b8916] +- Updated dependencies [f408f6f8] + - @lion/form-core@0.17.0 + - @lion/localize@0.24.0 + - @lion/input-tel@0.1.0 + ## 0.8.0 ### Minor Changes diff --git a/packages/validate-messages/package.json b/packages/validate-messages/package.json index 323da3f46..3527558d5 100644 --- a/packages/validate-messages/package.json +++ b/packages/validate-messages/package.json @@ -1,6 +1,6 @@ { "name": "@lion/validate-messages", - "version": "0.8.0", + "version": "0.9.0", "description": "A set of localized messages for default Validators", "license": "MIT", "author": "ing-bank", @@ -32,9 +32,9 @@ "test": "cd ../../ && npm run test:browser -- --group validate-messages" }, "dependencies": { - "@lion/form-core": "^0.16.0", - "@lion/localize": "^0.23.0", - "@lion/input-tel": "^0.0.0" + "@lion/form-core": "^0.17.0", + "@lion/input-tel": "^0.1.0", + "@lion/localize": "^0.24.0" }, "keywords": [ "feedback",