diff --git a/.changeset/bindings-translation-contract.md b/.changeset/bindings-translation-contract.md deleted file mode 100644 index 2ff7b6f..0000000 --- a/.changeset/bindings-translation-contract.md +++ /dev/null @@ -1,29 +0,0 @@ ---- -'@dunky.dev/state-machine-bindings': minor -'@dunky.dev/react-state-machine': patch -'@dunky.dev/native-state-machine': patch -'@dunky.dev/opentui-state-machine': patch ---- - -The translation contract: every target must account for every vocabulary key — -mapped, or `null` as a declared drop. Previously the normalize maps were -untyped, so a new binding compiled everywhere and silently leaked to the host; -now it's a compile error in every target until that target decides. - -Bindings exports the contract (`HandlerKey`/`AttrKey`, `HandlerTargets`/ -`AttrTargets`) and the all-dropped bases `DROPPED_HANDLERS`/`DROPPED_ATTRS` -for targets that express little of the vocabulary (they inherit `null` for -future keys; the compile error fires at the base): - -```ts -export const HANDLER_MAP: HandlerTargets = { - ...DROPPED_HANDLERS, // hover, keyboard, double-press, wheel: no RN analog - onPress: 'onPress', - onPointerDown: 'onPressIn', - // ...everything this target can express -} -``` - -No behavior change in the targets; a conformance test per target walks its -ledger and asserts every binding lands on its declared target — or, for a -`null`, nowhere at all. diff --git a/.changeset/pin-internal-deps.md b/.changeset/pin-internal-deps.md deleted file mode 100644 index bfe0a70..0000000 --- a/.changeset/pin-internal-deps.md +++ /dev/null @@ -1,18 +0,0 @@ ---- -'@dunky.dev/react-state-machine': patch -'@dunky.dev/native-state-machine': patch -'@dunky.dev/opentui-state-machine': patch ---- - -Internal dependencies on sibling workspace packages are now pinned to an -exact version instead of a caret range, and every package versions -independently — the `@dunky.dev/*` lockstep group is gone, so a release -never bumps a package whose code didn't change. - -A caret range between two packages that both sit above a shared dependency -lets a consumer's install resolve to two different physical copies of it -once those packages' required ranges drift apart, silently breaking anything -identity-sensitive in that shared dependency (a singleton, a `WeakMap`, -module-level state). Pinning exact collapses that to one resolvable version: -a mismatch now fails at publish time instead of surfacing as a runtime bug -in a consumer's app. diff --git a/packages/native/CHANGELOG.md b/packages/native/CHANGELOG.md index 422eb5e..8ec0269 100644 --- a/packages/native/CHANGELOG.md +++ b/packages/native/CHANGELOG.md @@ -1,5 +1,49 @@ # @dunky.dev/native-state-machine +## 0.3.3 + +### Patch Changes + +- [#57](https://github.com/dunky-dev/state-machine/pull/57) [`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19) Thanks [@ivanbanov](https://github.com/ivanbanov)! - The translation contract: every target must account for every vocabulary key — + mapped, or `null` as a declared drop. Previously the normalize maps were + untyped, so a new binding compiled everywhere and silently leaked to the host; + now it's a compile error in every target until that target decides. + + Bindings exports the contract (`HandlerKey`/`AttrKey`, `HandlerTargets`/ + `AttrTargets`) and the all-dropped bases `DROPPED_HANDLERS`/`DROPPED_ATTRS` + for targets that express little of the vocabulary (they inherit `null` for + future keys; the compile error fires at the base): + + ```ts + export const HANDLER_MAP: HandlerTargets = { + ...DROPPED_HANDLERS, // hover, keyboard, double-press, wheel: no RN analog + onPress: "onPress", + onPointerDown: "onPressIn", + // ...everything this target can express + }; + ``` + + No behavior change in the targets; a conformance test per target walks its + ledger and asserts every binding lands on its declared target — or, for a + `null`, nowhere at all. + +- [#59](https://github.com/dunky-dev/state-machine/pull/59) [`59f279e`](https://github.com/dunky-dev/state-machine/commit/59f279e8748d25f5c95999987bc1d944a9ff92d9) Thanks [@ivanbanov](https://github.com/ivanbanov)! - Internal dependencies on sibling workspace packages are now pinned to an + exact version instead of a caret range, and every package versions + independently — the `@dunky.dev/*` lockstep group is gone, so a release + never bumps a package whose code didn't change. + + A caret range between two packages that both sit above a shared dependency + lets a consumer's install resolve to two different physical copies of it + once those packages' required ranges drift apart, silently breaking anything + identity-sensitive in that shared dependency (a singleton, a `WeakMap`, + module-level state). Pinning exact collapses that to one resolvable version: + a mismatch now fails at publish time instead of surfacing as a runtime bug + in a consumer's app. + +- Updated dependencies [[`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19), [`59f279e`](https://github.com/dunky-dev/state-machine/commit/59f279e8748d25f5c95999987bc1d944a9ff92d9)]: + - @dunky.dev/state-machine-bindings@0.4.0 + - @dunky.dev/react-state-machine@0.3.3 + ## 0.3.2 ### Patch Changes diff --git a/packages/native/package.json b/packages/native/package.json index 588ea25..967194e 100644 --- a/packages/native/package.json +++ b/packages/native/package.json @@ -1,6 +1,6 @@ { "name": "@dunky.dev/native-state-machine", - "version": "0.3.2", + "version": "0.3.3", "license": "MIT", "repository": { "type": "git", diff --git a/packages/opentui/CHANGELOG.md b/packages/opentui/CHANGELOG.md index a5b6717..0ad5893 100644 --- a/packages/opentui/CHANGELOG.md +++ b/packages/opentui/CHANGELOG.md @@ -1,5 +1,48 @@ # @dunky.dev/opentui-state-machine +## 0.3.3 + +### Patch Changes + +- [#57](https://github.com/dunky-dev/state-machine/pull/57) [`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19) Thanks [@ivanbanov](https://github.com/ivanbanov)! - The translation contract: every target must account for every vocabulary key — + mapped, or `null` as a declared drop. Previously the normalize maps were + untyped, so a new binding compiled everywhere and silently leaked to the host; + now it's a compile error in every target until that target decides. + + Bindings exports the contract (`HandlerKey`/`AttrKey`, `HandlerTargets`/ + `AttrTargets`) and the all-dropped bases `DROPPED_HANDLERS`/`DROPPED_ATTRS` + for targets that express little of the vocabulary (they inherit `null` for + future keys; the compile error fires at the base): + + ```ts + export const HANDLER_MAP: HandlerTargets = { + ...DROPPED_HANDLERS, // hover, keyboard, double-press, wheel: no RN analog + onPress: "onPress", + onPointerDown: "onPressIn", + // ...everything this target can express + }; + ``` + + No behavior change in the targets; a conformance test per target walks its + ledger and asserts every binding lands on its declared target — or, for a + `null`, nowhere at all. + +- [#59](https://github.com/dunky-dev/state-machine/pull/59) [`59f279e`](https://github.com/dunky-dev/state-machine/commit/59f279e8748d25f5c95999987bc1d944a9ff92d9) Thanks [@ivanbanov](https://github.com/ivanbanov)! - Internal dependencies on sibling workspace packages are now pinned to an + exact version instead of a caret range, and every package versions + independently — the `@dunky.dev/*` lockstep group is gone, so a release + never bumps a package whose code didn't change. + + A caret range between two packages that both sit above a shared dependency + lets a consumer's install resolve to two different physical copies of it + once those packages' required ranges drift apart, silently breaking anything + identity-sensitive in that shared dependency (a singleton, a `WeakMap`, + module-level state). Pinning exact collapses that to one resolvable version: + a mismatch now fails at publish time instead of surfacing as a runtime bug + in a consumer's app. + +- Updated dependencies [[`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19)]: + - @dunky.dev/state-machine-bindings@0.4.0 + ## 0.3.2 ### Patch Changes diff --git a/packages/opentui/package.json b/packages/opentui/package.json index 79f74f8..39a9349 100644 --- a/packages/opentui/package.json +++ b/packages/opentui/package.json @@ -1,6 +1,6 @@ { "name": "@dunky.dev/opentui-state-machine", - "version": "0.3.2", + "version": "0.3.3", "license": "MIT", "repository": { "type": "git", diff --git a/packages/react/CHANGELOG.md b/packages/react/CHANGELOG.md index 6be1b73..5a68b09 100644 --- a/packages/react/CHANGELOG.md +++ b/packages/react/CHANGELOG.md @@ -1,5 +1,45 @@ # @dunky.dev/react-state-machine +## 0.3.3 + +### Patch Changes + +- [#57](https://github.com/dunky-dev/state-machine/pull/57) [`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19) Thanks [@ivanbanov](https://github.com/ivanbanov)! - The translation contract: every target must account for every vocabulary key — + mapped, or `null` as a declared drop. Previously the normalize maps were + untyped, so a new binding compiled everywhere and silently leaked to the host; + now it's a compile error in every target until that target decides. + + Bindings exports the contract (`HandlerKey`/`AttrKey`, `HandlerTargets`/ + `AttrTargets`) and the all-dropped bases `DROPPED_HANDLERS`/`DROPPED_ATTRS` + for targets that express little of the vocabulary (they inherit `null` for + future keys; the compile error fires at the base): + + ```ts + export const HANDLER_MAP: HandlerTargets = { + ...DROPPED_HANDLERS, // hover, keyboard, double-press, wheel: no RN analog + onPress: "onPress", + onPointerDown: "onPressIn", + // ...everything this target can express + }; + ``` + + No behavior change in the targets; a conformance test per target walks its + ledger and asserts every binding lands on its declared target — or, for a + `null`, nowhere at all. + +- [#59](https://github.com/dunky-dev/state-machine/pull/59) [`59f279e`](https://github.com/dunky-dev/state-machine/commit/59f279e8748d25f5c95999987bc1d944a9ff92d9) Thanks [@ivanbanov](https://github.com/ivanbanov)! - Internal dependencies on sibling workspace packages are now pinned to an + exact version instead of a caret range, and every package versions + independently — the `@dunky.dev/*` lockstep group is gone, so a release + never bumps a package whose code didn't change. + + A caret range between two packages that both sit above a shared dependency + lets a consumer's install resolve to two different physical copies of it + once those packages' required ranges drift apart, silently breaking anything + identity-sensitive in that shared dependency (a singleton, a `WeakMap`, + module-level state). Pinning exact collapses that to one resolvable version: + a mismatch now fails at publish time instead of surfacing as a runtime bug + in a consumer's app. + ## 0.3.2 ### Patch Changes diff --git a/packages/react/package.json b/packages/react/package.json index 737c0e8..9ddc5fa 100644 --- a/packages/react/package.json +++ b/packages/react/package.json @@ -1,6 +1,6 @@ { "name": "@dunky.dev/react-state-machine", - "version": "0.3.2", + "version": "0.3.3", "license": "MIT", "repository": { "type": "git", diff --git a/packages/shared/bindings/CHANGELOG.md b/packages/shared/bindings/CHANGELOG.md index a742dd3..8a64062 100644 --- a/packages/shared/bindings/CHANGELOG.md +++ b/packages/shared/bindings/CHANGELOG.md @@ -1,5 +1,32 @@ # @dunky.dev/state-machine-bindings +## 0.4.0 + +### Minor Changes + +- [#57](https://github.com/dunky-dev/state-machine/pull/57) [`2532b06`](https://github.com/dunky-dev/state-machine/commit/2532b066455c7b1cd3c03eda270d8ce53498df19) Thanks [@ivanbanov](https://github.com/ivanbanov)! - The translation contract: every target must account for every vocabulary key — + mapped, or `null` as a declared drop. Previously the normalize maps were + untyped, so a new binding compiled everywhere and silently leaked to the host; + now it's a compile error in every target until that target decides. + + Bindings exports the contract (`HandlerKey`/`AttrKey`, `HandlerTargets`/ + `AttrTargets`) and the all-dropped bases `DROPPED_HANDLERS`/`DROPPED_ATTRS` + for targets that express little of the vocabulary (they inherit `null` for + future keys; the compile error fires at the base): + + ```ts + export const HANDLER_MAP: HandlerTargets = { + ...DROPPED_HANDLERS, // hover, keyboard, double-press, wheel: no RN analog + onPress: "onPress", + onPointerDown: "onPressIn", + // ...everything this target can express + }; + ``` + + No behavior change in the targets; a conformance test per target walks its + ledger and asserts every binding lands on its declared target — or, for a + `null`, nowhere at all. + ## 0.3.2 ### Patch Changes diff --git a/packages/shared/bindings/package.json b/packages/shared/bindings/package.json index 3f5340f..5d660a1 100644 --- a/packages/shared/bindings/package.json +++ b/packages/shared/bindings/package.json @@ -1,6 +1,6 @@ { "name": "@dunky.dev/state-machine-bindings", - "version": "0.3.2", + "version": "0.4.0", "license": "MIT", "repository": { "type": "git",