From 9951679babf6ddd8979983727f9a139903aa24ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Fri, 12 Jun 2026 22:22:15 +0200 Subject: [PATCH 01/24] feat: type-safe .riv schema system (POC) Adds a codegen pipeline that extracts artboard/SM/ViewModel schemas from .riv files at build time and exposes them as TypeScript phantom types. RiveView, useRiveFile, useRiveNumber/String/Boolean/Color/Trigger, and useViewModelInstance all gain typed overloads so wrong artboard names, state machine names, or property paths are caught at compile time. Scripts: rive-extract-schema.ts (WASM-based extractor), rive-gen-types.ts (generates .riv.d.ts alongside assets), with bun tests for both. Type-level tests via tsd in src/__tests__/typed-rive.test-d.ts. --- eslint.config.mjs | 1 + example/assets/rive/GradientBorder.riv.d.ts | 17 ++ example/assets/rive/artboard_db_test.riv.d.ts | 21 ++ example/assets/rive/blinko.riv.d.ts | 97 ++++++++ example/assets/rive/bouncing_ball.riv.d.ts | 17 ++ example/assets/rive/counter.riv.d.ts | 17 ++ example/assets/rive/databinding.riv.d.ts | 28 +++ .../assets/rive/databinding_images.riv.d.ts | 17 ++ .../assets/rive/databinding_lists.riv.d.ts | 20 ++ example/assets/rive/fallback_fonts.riv.d.ts | 12 + example/assets/rive/font_fallback.riv.d.ts | 17 ++ example/assets/rive/hello_world_text.riv.d.ts | 12 + example/assets/rive/inputglow.riv.d.ts | 17 ++ .../ios_android_layouts_demo_v01.riv.d.ts | 12 + example/assets/rive/layout_test.riv.d.ts | 17 ++ example/assets/rive/layouts_demo.riv.d.ts | 12 + example/assets/rive/many_viewmodels.riv.d.ts | 19 ++ example/assets/rive/movecircle.riv.d.ts | 17 ++ .../assets/rive/nodefaultbouncing.riv.d.ts | 17 ++ example/assets/rive/on_entry_test.riv.d.ts | 18 ++ example/assets/rive/out_of_band.riv.d.ts | 12 + example/assets/rive/quick_start.riv.d.ts | 21 ++ example/assets/rive/rating.riv.d.ts | 12 + example/assets/rive/rewards.riv.d.ts | 51 ++++ .../assets/rive/style_fallback_fonts.riv.d.ts | 12 + .../assets/rive/viewmodelproperty.riv.d.ts | 21 ++ .../assets/rive/vm_value_change_test.riv.d.ts | 18 ++ example/src/exercisers/FileSwitcher.tsx | 207 ++++++++++++++++ package.json | 21 +- scripts/__tests__/rive-extract-schema.test.ts | 48 ++++ scripts/__tests__/rive-gen-types.test.ts | 45 ++++ scripts/rive-extract-schema.ts | 105 ++++++++ scripts/rive-gen-types.ts | 189 +++++++++++++++ src/__tests__/typed-rive.test-d.ts | 207 ++++++++++++++++ src/core/RiveFile.ts | 66 ++--- src/core/RiveView.tsx | 54 ++--- src/core/TypedRiveFile.ts | 43 ++++ src/core/TypedViewModelInstance.ts | 152 ++++++++++++ src/hooks/useRiveBoolean.ts | 13 + src/hooks/useRiveColor.ts | 13 + src/hooks/useRiveFile.ts | 12 + src/hooks/useRiveNumber.ts | 13 + src/hooks/useRiveString.ts | 13 + src/hooks/useRiveTrigger.ts | 15 ++ src/hooks/useViewModelInstance.ts | 14 ++ src/index.tsx | 2 + tsconfig.json | 2 +- yarn.lock | 229 ++++++++++++++++-- 48 files changed, 1917 insertions(+), 98 deletions(-) create mode 100644 example/assets/rive/GradientBorder.riv.d.ts create mode 100644 example/assets/rive/artboard_db_test.riv.d.ts create mode 100644 example/assets/rive/blinko.riv.d.ts create mode 100644 example/assets/rive/bouncing_ball.riv.d.ts create mode 100644 example/assets/rive/counter.riv.d.ts create mode 100644 example/assets/rive/databinding.riv.d.ts create mode 100644 example/assets/rive/databinding_images.riv.d.ts create mode 100644 example/assets/rive/databinding_lists.riv.d.ts create mode 100644 example/assets/rive/fallback_fonts.riv.d.ts create mode 100644 example/assets/rive/font_fallback.riv.d.ts create mode 100644 example/assets/rive/hello_world_text.riv.d.ts create mode 100644 example/assets/rive/inputglow.riv.d.ts create mode 100644 example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts create mode 100644 example/assets/rive/layout_test.riv.d.ts create mode 100644 example/assets/rive/layouts_demo.riv.d.ts create mode 100644 example/assets/rive/many_viewmodels.riv.d.ts create mode 100644 example/assets/rive/movecircle.riv.d.ts create mode 100644 example/assets/rive/nodefaultbouncing.riv.d.ts create mode 100644 example/assets/rive/on_entry_test.riv.d.ts create mode 100644 example/assets/rive/out_of_band.riv.d.ts create mode 100644 example/assets/rive/quick_start.riv.d.ts create mode 100644 example/assets/rive/rating.riv.d.ts create mode 100644 example/assets/rive/rewards.riv.d.ts create mode 100644 example/assets/rive/style_fallback_fonts.riv.d.ts create mode 100644 example/assets/rive/viewmodelproperty.riv.d.ts create mode 100644 example/assets/rive/vm_value_change_test.riv.d.ts create mode 100644 example/src/exercisers/FileSwitcher.tsx create mode 100644 scripts/__tests__/rive-extract-schema.test.ts create mode 100644 scripts/__tests__/rive-gen-types.test.ts create mode 100644 scripts/rive-extract-schema.ts create mode 100644 scripts/rive-gen-types.ts create mode 100644 src/__tests__/typed-rive.test-d.ts create mode 100644 src/core/TypedRiveFile.ts create mode 100644 src/core/TypedViewModelInstance.ts diff --git a/eslint.config.mjs b/eslint.config.mjs index 447ee604..7fc27c0d 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -54,6 +54,7 @@ export default defineConfig([ 'node_modules/', 'lib/', '**/.expo/', + '**/*.test-d.ts', ], }, ]); diff --git a/example/assets/rive/GradientBorder.riv.d.ts b/example/assets/rive/GradientBorder.riv.d.ts new file mode 100644 index 00000000..3fdc9e8e --- /dev/null +++ b/example/assets/rive/GradientBorder.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: GradientBorder.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Layout'; + defaultArtboard: 'Layout'; + stateMachines: { + 'Layout': 'State'; + }; + viewModels: { + 'ViewModel': { + 'isFocused': 'boolean'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/artboard_db_test.riv.d.ts b/example/assets/rive/artboard_db_test.riv.d.ts new file mode 100644 index 00000000..33d2c567 --- /dev/null +++ b/example/assets/rive/artboard_db_test.riv.d.ts @@ -0,0 +1,21 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: artboard_db_test.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Main' | 'ArtboardGreen' | 'ArtboardBlue' | 'ArtboardRed'; + defaultArtboard: 'Main'; + stateMachines: { + 'Main': 'State Machine 1'; + 'ArtboardGreen': 'State Machine 1'; + 'ArtboardBlue': 'State Machine 1'; + 'ArtboardRed': 'State Machine 1'; + }; + viewModels: { + 'MainViewModel': { + 'artboard_1': 'artboard'; + 'artboard_2': 'artboard'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/blinko.riv.d.ts b/example/assets/rive/blinko.riv.d.ts new file mode 100644 index 00000000..21865be3 --- /dev/null +++ b/example/assets/rive/blinko.riv.d.ts @@ -0,0 +1,97 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: blinko.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Main' | 'StoreItem' | 'Token' | 'Indicator' | 'Puck' | 'StoreIcon' | 'Peg' | 'scoreBox'; + defaultArtboard: 'Main'; + stateMachines: { + 'Main': 'State Machine 1'; + 'StoreItem': 'State Machine 1'; + 'Token': 'State Machine 1'; + 'Indicator': 'State Machine 1'; + 'Puck': 'State Machine 1'; + 'StoreIcon': 'State Machine 1'; + 'Peg': 'State Machine 1'; + 'scoreBox': 'State Machine 1'; + }; + viewModels: { + 'IndicatorVM': { + 'purchased': 'boolean'; + }; + 'StoreItemVM': { + 'tokenCount': 'number'; + 'height': 'number'; + 'itemHover': 'boolean'; + 'cost': 'number'; + 'description': 'string'; + 'id': 'string'; + 'itemType': 'string'; + 'maxPurchases': 'number'; + 'name': 'string'; + 'purchase': 'trigger'; + 'purchaseCount': 'number'; + }; + 'storeIconVM': { + 'storeiconClick': 'trigger'; + 'iconHovered': 'boolean'; + }; + 'storeVM': { + 'xbuttonClick': 'trigger'; + 'xbuttonHover': 'boolean'; + 'items': 'list'; + 'storeOpen': 'boolean'; + 'property of pegVM': 'viewModel:pegVM'; + 'multiplierValue': 'number'; + 'extraTokenSlotActive': 'boolean'; + 'extraTokenSlotCost': 'number'; + 'extraTokenSlotCount': 'number'; + 'purchaseExtraTokenSlot': 'trigger'; + 'purchaseSuperMultiplier': 'trigger'; + 'superMultiplierActive': 'boolean'; + 'superMultiplierCost': 'number'; + 'superMultiplierCount': 'number'; + }; + 'TokenVM': { + 'spinToken': 'boolean'; + }; + 'pegVM': { + 'blink': 'trigger'; + 'multiplierValue': 'number'; + 'pegType': 'enumType'; + 'pegBounced': 'trigger'; + }; + 'gameLogicVM': { + 'turnTokens': 'number'; + 'turnScore': 'number'; + 'buttonLabel': 'string'; + 'message': 'string'; + 'startTurn': 'trigger'; + 'turnEnded': 'trigger'; + 'gameEnded': 'boolean'; + 'tokenCount': 'number'; + 'scoreTotal': 'number'; + }; + 'scoreBox': { + 'Token': 'viewModel:TokenVM'; + 'slotType': 'enumType'; + 'landed': 'trigger'; + 'scoreValue': 'number'; + }; + 'PuckVM': { + 'puckBounce': 'trigger'; + 'puckRotation': 'number'; + }; + 'main': { + 'PuckVM': 'viewModel:PuckVM'; + 'storeItemVM': 'viewModel:StoreItemVM'; + 'storeIconVM': 'viewModel:storeIconVM'; + 'pegVM': 'viewModel:pegVM'; + 'storeVM': 'viewModel:storeVM'; + 'buttonHover': 'boolean'; + 'tokenVM': 'viewModel:TokenVM'; + 'property of gameLogicVM': 'viewModel:gameLogicVM'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/bouncing_ball.riv.d.ts b/example/assets/rive/bouncing_ball.riv.d.ts new file mode 100644 index 00000000..b6d2574d --- /dev/null +++ b/example/assets/rive/bouncing_ball.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: bouncing_ball.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'vm': { + 'ypos': 'number'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/counter.riv.d.ts b/example/assets/rive/counter.riv.d.ts new file mode 100644 index 00000000..b1ba266a --- /dev/null +++ b/example/assets/rive/counter.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: counter.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'ViewModel1': { + 'cnt': 'number'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/databinding.riv.d.ts b/example/assets/rive/databinding.riv.d.ts new file mode 100644 index 00000000..d7668f52 --- /dev/null +++ b/example/assets/rive/databinding.riv.d.ts @@ -0,0 +1,28 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: databinding.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'Person': { + 'pet': 'viewModel:Pet'; + 'jump': 'trigger'; + 'likes_popcorn': 'boolean'; + 'favourite_pet': 'enumType'; + 'favourite_color': 'color'; + 'age': 'number'; + 'website': 'string'; + 'name': 'string'; + }; + 'Pet': { + 'type': 'enumType'; + 'name': 'string'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/databinding_images.riv.d.ts b/example/assets/rive/databinding_images.riv.d.ts new file mode 100644 index 00000000..6d788405 --- /dev/null +++ b/example/assets/rive/databinding_images.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: databinding_images.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'MyViewModel': { + 'bound_image': 'image'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/databinding_lists.riv.d.ts b/example/assets/rive/databinding_lists.riv.d.ts new file mode 100644 index 00000000..75795551 --- /dev/null +++ b/example/assets/rive/databinding_lists.riv.d.ts @@ -0,0 +1,20 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: databinding_lists.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'Person': { + 'name': 'string'; + }; + 'DevRel': { + 'team': 'list'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/fallback_fonts.riv.d.ts b/example/assets/rive/fallback_fonts.riv.d.ts new file mode 100644 index 00000000..ab210750 --- /dev/null +++ b/example/assets/rive/fallback_fonts.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: fallback_fonts.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/font_fallback.riv.d.ts b/example/assets/rive/font_fallback.riv.d.ts new file mode 100644 index 00000000..367dd2ab --- /dev/null +++ b/example/assets/rive/font_fallback.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: font_fallback.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'ViewModel': { + 'text': 'string'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/hello_world_text.riv.d.ts b/example/assets/rive/hello_world_text.riv.d.ts new file mode 100644 index 00000000..4e879f1e --- /dev/null +++ b/example/assets/rive/hello_world_text.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: hello_world_text.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'New Artboard'; + defaultArtboard: 'New Artboard'; + stateMachines: { + 'New Artboard': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/inputglow.riv.d.ts b/example/assets/rive/inputglow.riv.d.ts new file mode 100644 index 00000000..3b51f663 --- /dev/null +++ b/example/assets/rive/inputglow.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: inputglow.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Layout'; + defaultArtboard: 'Layout'; + stateMachines: { + 'Layout': 'State'; + }; + viewModels: { + 'ViewModel': { + 'isFocused': 'boolean'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts new file mode 100644 index 00000000..80be047c --- /dev/null +++ b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: ios_android_layouts_demo_v01.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'iOS_Android_Layouts_demo_v01'; + defaultArtboard: 'iOS_Android_Layouts_demo_v01'; + stateMachines: { + 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/layout_test.riv.d.ts b/example/assets/rive/layout_test.riv.d.ts new file mode 100644 index 00000000..008fd913 --- /dev/null +++ b/example/assets/rive/layout_test.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: layout_test.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'ViewModel1': { + + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/layouts_demo.riv.d.ts b/example/assets/rive/layouts_demo.riv.d.ts new file mode 100644 index 00000000..a5587ce3 --- /dev/null +++ b/example/assets/rive/layouts_demo.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: layouts_demo.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'iOS_Android_Layouts_demo_v01'; + defaultArtboard: 'iOS_Android_Layouts_demo_v01'; + stateMachines: { + 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/many_viewmodels.riv.d.ts b/example/assets/rive/many_viewmodels.riv.d.ts new file mode 100644 index 00000000..2a890294 --- /dev/null +++ b/example/assets/rive/many_viewmodels.riv.d.ts @@ -0,0 +1,19 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: many_viewmodels.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'First': { + 'imageValue': 'image'; + 'colorValue': 'color'; + 'textValue': 'string'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/movecircle.riv.d.ts b/example/assets/rive/movecircle.riv.d.ts new file mode 100644 index 00000000..f63db94b --- /dev/null +++ b/example/assets/rive/movecircle.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: movecircle.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'ViewModel': { + 'posY': 'number'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/nodefaultbouncing.riv.d.ts b/example/assets/rive/nodefaultbouncing.riv.d.ts new file mode 100644 index 00000000..9a16de8e --- /dev/null +++ b/example/assets/rive/nodefaultbouncing.riv.d.ts @@ -0,0 +1,17 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: nodefaultbouncing.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'VM1': { + + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/on_entry_test.riv.d.ts b/example/assets/rive/on_entry_test.riv.d.ts new file mode 100644 index 00000000..81e4ef07 --- /dev/null +++ b/example/assets/rive/on_entry_test.riv.d.ts @@ -0,0 +1,18 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: on_entry_test.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'vm': { + 'input': 'number'; + 'inputOnEntry': 'number'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/out_of_band.riv.d.ts b/example/assets/rive/out_of_band.riv.d.ts new file mode 100644 index 00000000..8b22e950 --- /dev/null +++ b/example/assets/rive/out_of_band.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: out_of_band.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/quick_start.riv.d.ts b/example/assets/rive/quick_start.riv.d.ts new file mode 100644 index 00000000..b3abbe6b --- /dev/null +++ b/example/assets/rive/quick_start.riv.d.ts @@ -0,0 +1,21 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: quick_start.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'health_bar_v01'; + defaultArtboard: 'health_bar_v01'; + stateMachines: { + 'health_bar_v01': 'State Machine 1'; + }; + viewModels: { + 'health_bar_01': { + 'gameOver': 'trigger'; + 'hoverYes': 'boolean'; + 'hoverNo': 'boolean'; + 'healthColor': 'color'; + 'health': 'number'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/rating.riv.d.ts b/example/assets/rive/rating.riv.d.ts new file mode 100644 index 00000000..35be7041 --- /dev/null +++ b/example/assets/rive/rating.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: rating.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'New Artboard'; + defaultArtboard: 'New Artboard'; + stateMachines: { + 'New Artboard': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts new file mode 100644 index 00000000..82b09211 --- /dev/null +++ b/example/assets/rive/rewards.riv.d.ts @@ -0,0 +1,51 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: rewards.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Main' | 'Lives 2' | 'Item Value' | 'Chest' | 'Button' | 'Heart' | 'Item'; + defaultArtboard: 'Main'; + stateMachines: { + 'Main': 'State Machine 1'; + 'Lives 2': 'State Machine 1'; + 'Item Value': 'State Machine 1'; + 'Chest': 'State Machine 1'; + 'Button': 'State Machine 1'; + 'Heart': 'State Machine 1'; + 'Item': 'State Machine 1'; + }; + viewModels: { + 'Item_Icon_Value': { + 'Icon_React': 'trigger'; + 'Property_Of_Item': 'viewModel:Item'; + 'Item_Value': 'number'; + }; + 'Energy_Bar': { + 'Bar_Color': 'color'; + 'Lives': 'number'; + 'Energy_Bar': 'number'; + }; + 'Rewards': { + 'Price_Value': 'number'; + 'Color': 'color'; + 'Height': 'number'; + 'With': 'number'; + 'Item_Selection': 'viewModel:Item'; + 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; + 'Button': 'viewModel:Button'; + 'Coin': 'viewModel:Item_Icon_Value'; + 'Gem': 'viewModel:Item_Icon_Value'; + 'Energy_Bar': 'viewModel:Energy_Bar'; + }; + 'Button': { + 'State_1': 'string'; + 'Item_Text': 'string'; + 'Item': 'viewModel:Item'; + 'Pressed': 'trigger'; + }; + 'Item': { + 'Item_Selection': 'enumType'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/style_fallback_fonts.riv.d.ts b/example/assets/rive/style_fallback_fonts.riv.d.ts new file mode 100644 index 00000000..8e64cf29 --- /dev/null +++ b/example/assets/rive/style_fallback_fonts.riv.d.ts @@ -0,0 +1,12 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: style_fallback_fonts.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; +}>; +export default asset; diff --git a/example/assets/rive/viewmodelproperty.riv.d.ts b/example/assets/rive/viewmodelproperty.riv.d.ts new file mode 100644 index 00000000..744ad485 --- /dev/null +++ b/example/assets/rive/viewmodelproperty.riv.d.ts @@ -0,0 +1,21 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: viewmodelproperty.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'root': { + 'vm2': 'viewModel:vm'; + 'vm1': 'viewModel:vm'; + }; + 'vm': { + 'name': 'string'; + }; + }; +}>; +export default asset; diff --git a/example/assets/rive/vm_value_change_test.riv.d.ts b/example/assets/rive/vm_value_change_test.riv.d.ts new file mode 100644 index 00000000..674ed043 --- /dev/null +++ b/example/assets/rive/vm_value_change_test.riv.d.ts @@ -0,0 +1,18 @@ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: vm_value_change_test.riv +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ + artboards: 'Artboard'; + defaultArtboard: 'Artboard'; + stateMachines: { + 'Artboard': 'State Machine 1'; + }; + viewModels: { + 'TextModel': { + 'trigger': 'trigger'; + 'textValue': 'string'; + }; + }; +}>; +export default asset; diff --git a/example/src/exercisers/FileSwitcher.tsx b/example/src/exercisers/FileSwitcher.tsx new file mode 100644 index 00000000..d29671b6 --- /dev/null +++ b/example/src/exercisers/FileSwitcher.tsx @@ -0,0 +1,207 @@ +/** + * File Switcher Exerciser + * + * Rapidly switch between .riv files with different fit modes to test for + * crashes related to dispose/render races. + * + * Reproduces "Should not already be working" crash seen on RN 0.83. + */ + +import { useState } from 'react'; +import { + type DimensionValue, + Pressable, + ScrollView, + StyleSheet, + Text, + View, +} from 'react-native'; +import { Fit, RiveView, useRiveFile } from '@rive-app/react-native'; +import { type Metadata } from '../shared/metadata'; + +const FILES = [ + { + label: 'layout_test', + source: require('../../assets/rive/layout_test.riv'), + }, + { label: 'inputglow', source: require('../../assets/rive/inputglow.riv') }, + { + label: 'GradientBorder', + source: require('../../assets/rive/GradientBorder.riv'), + }, + { + label: 'layouts_demo', + source: require('../../assets/rive/layouts_demo.riv'), + }, + { + label: 'bouncing_ball', + source: require('../../assets/rive/bouncing_ball.riv'), + }, + { label: 'counter', source: require('../../assets/rive/counter.riv') }, + { label: 'rating', source: require('../../assets/rive/rating.riv') }, +] as const; + +const FITS = [ + { label: 'Layout', value: Fit.Layout }, + { label: 'Contain', value: Fit.Contain }, + { label: 'Cover', value: Fit.Cover }, + { label: 'Fill', value: Fit.Fill }, +] as const; + +const SIZES = [ + { label: 'full x 150', width: '100%' as const, height: 150 }, + { label: 'full x 80', width: '100%' as const, height: 80 }, + { label: '200 x 120', width: 200, height: 120 }, +]; + +function RiveBox({ + source, + fit, + height, + width, +}: { + source: number; + fit: Fit; + height: number; + width: DimensionValue; +}) { + const { riveFile } = useRiveFile(source); + + return ( + + {riveFile && ( + + )} + + ); +} + +function Chip({ + label, + selected, + onPress, +}: { + label: string; + selected: boolean; + onPress: () => void; +}) { + return ( + + + {label} + + + ); +} + +export const metadata: Metadata = { + name: 'File Switcher', + description: 'Rapidly switch files/fits to test dispose/render race crashes', +}; + +export default function FileSwitcher() { + const [fileIdx, setFileIdx] = useState(0); + const [fitIdx, setFitIdx] = useState(0); + + const file = FILES[fileIdx]!; + const fit = FITS[fitIdx]!; + + return ( + + File + + {FILES.map((f, i) => ( + setFileIdx(i)} + /> + ))} + + + Fit + + {FITS.map((f, i) => ( + setFitIdx(i)} + /> + ))} + + + + {file.label} — Fit.{fit.label} + + {SIZES.map((size) => ( + + {size.label} + + + ))} + + ); +} + +const styles = StyleSheet.create({ + container: { + flex: 1, + backgroundColor: '#0c1027', + }, + content: { + padding: 20, + paddingBottom: 60, + }, + section: { + color: '#fff', + fontSize: 16, + fontWeight: 'bold', + marginTop: 16, + marginBottom: 8, + }, + chips: { + flexDirection: 'row', + flexWrap: 'wrap', + gap: 8, + }, + chip: { + paddingHorizontal: 12, + paddingVertical: 6, + borderRadius: 16, + borderWidth: 1, + borderColor: '#555', + }, + chipSelected: { + backgroundColor: '#4f6ef7', + borderColor: '#4f6ef7', + }, + chipText: { + color: '#999', + fontSize: 13, + }, + chipTextSelected: { + color: '#fff', + }, + item: { + marginBottom: 16, + }, + label: { + color: '#999', + fontSize: 12, + marginBottom: 4, + }, + riveBox: { + borderWidth: 1, + borderColor: 'red', + }, +}); diff --git a/package.json b/package.json index 7688d957..50789c36 100644 --- a/package.json +++ b/package.json @@ -40,13 +40,16 @@ "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib", "prepare": "npx react-native-builder-bob@^0.40.0 build", "nitrogen": "nitrogen && npx tsx scripts/nitrogen-postprocess.ts", + "rive-gen-types": "bun scripts/rive-gen-types.ts", "release": "release-it", "dev:ios": "cd example && xed ios", "dev:android": "cd example && open -a \"/Applications/Android Studio.app\" ./android", "copy:nitrogen-config": "mkdir -p lib/nitrogen/generated/shared/json && cp nitrogen/generated/shared/json/RiveViewConfig.json lib/nitrogen/generated/shared/json/", "lint:swift": "./scripts/lint-swift.sh", "lint:kotlin": "./scripts/lint-kotlin.sh", - "lint:native": "yarn lint:swift && yarn lint:kotlin" + "lint:native": "yarn lint:swift && yarn lint:kotlin", + "typetest": "tsd --typings src/index.tsx", + "test:scripts": "cd scripts/__tests__ && bun test --no-parallel" }, "keywords": [ "react-native", @@ -78,6 +81,7 @@ "@react-native/babel-preset": "0.79.2", "@react-native/eslint-config": "^0.78.0", "@release-it/conventional-changelog": "^9.0.2", + "@rive-app/canvas": "^2.38.0", "@testing-library/react-hooks": "^8.0.1", "@testing-library/react-native": "^13.3.3", "@types/jest": "^29.5.5", @@ -100,6 +104,7 @@ "react-native-nitro-modules": "0.35.0", "react-test-renderer": "19.0.0", "release-it": "^17.10.0", + "tsd": "^0.33.0", "turbo": "^1.10.7", "typescript": "^5.2.2" }, @@ -188,6 +193,20 @@ ] ] }, + "tsd": { + "typings": "src/index.tsx", + "directory": "src/__tests__", + "compilerOptions": { + "paths": { + "@rive-app/react-native": ["./src/index"] + }, + "moduleResolution": "bundler", + "jsx": "react-jsx", + "lib": ["ESNext"], + "strict": true, + "allowArbitraryExtensions": true + } + }, "create-react-native-library": { "languages": "kotlin-swift", "type": "nitro-module", diff --git a/scripts/__tests__/rive-extract-schema.test.ts b/scripts/__tests__/rive-extract-schema.test.ts new file mode 100644 index 00000000..d02cff50 --- /dev/null +++ b/scripts/__tests__/rive-extract-schema.test.ts @@ -0,0 +1,48 @@ +import { describe, test, expect, beforeAll } from 'bun:test'; +import { spawnSync } from 'child_process'; +import { resolve } from 'path'; + +const EXTRACTOR = resolve(__dirname, '../rive-extract-schema.ts'); +const REWARDS_RIV = resolve(__dirname, '../../example/assets/rive/rewards.riv'); + +function extract(path: string) { + const result = spawnSync('bun', [EXTRACTOR, path], { + encoding: 'utf8', + timeout: 30_000, + cwd: resolve(__dirname, '../..'), + }); + if (result.status !== 0) throw new Error(result.stderr ?? 'extractor failed'); + return JSON.parse(result.stdout) as Record; +} + +describe('rive-extract-schema', () => { + let schema: ReturnType; + + beforeAll(() => { + schema = extract(REWARDS_RIV); + }); + + test('extracts artboards', () => { + expect(schema.artboards).toContain('Main'); + expect(schema.defaultArtboard).toBe('Main'); + }); + + test('extracts state machines per artboard', () => { + expect((schema.stateMachines as Record)['Main']).toContain('State Machine 1'); + }); + + test('extracts viewModels', () => { + expect((schema.viewModels as Record)['Rewards']).toBeDefined(); + }); + + test('resolves nested viewModel references', () => { + const vms = schema.viewModels as Record>; + expect(vms['Rewards']!['Coin']).toBe('viewModel:Item_Icon_Value'); + }); + + test('extracts primitive property types', () => { + const vms = schema.viewModels as Record>; + expect(vms['Item_Icon_Value']!['Item_Value']).toBe('number'); + expect(vms['Energy_Bar']!['Bar_Color']).toBe('color'); + }); +}); diff --git a/scripts/__tests__/rive-gen-types.test.ts b/scripts/__tests__/rive-gen-types.test.ts new file mode 100644 index 00000000..9855973d --- /dev/null +++ b/scripts/__tests__/rive-gen-types.test.ts @@ -0,0 +1,45 @@ +import { describe, test, expect, beforeAll } from 'bun:test'; +import { spawnSync } from 'child_process'; +import { resolve } from 'path'; +import { readFileSync, existsSync } from 'fs'; + +const GENERATOR = resolve(__dirname, '../rive-gen-types.ts'); +const REWARDS_RIV = resolve(__dirname, '../../example/assets/rive/rewards.riv'); +const OUT_DTS = `${REWARDS_RIV}.d.ts`; + +describe('rive-gen-types', () => { + beforeAll(() => { + const result = spawnSync('bun', [GENERATOR, REWARDS_RIV], { + encoding: 'utf8', + timeout: 30_000, + cwd: resolve(__dirname, '../..'), + }); + if (result.status !== 0) throw new Error(result.stderr ?? 'generator failed'); + }); + + test('generates .riv.d.ts next to source file', () => { + expect(existsSync(OUT_DTS)).toBe(true); + }); + + test('generated file declares a RiveAsset default export', () => { + const content = readFileSync(OUT_DTS, 'utf8'); + expect(content).toContain('declare const asset: RiveAsset<'); + expect(content).toContain('export default asset'); + }); + + test('generated file contains artboard types', () => { + const content = readFileSync(OUT_DTS, 'utf8'); + expect(content).toContain("'Main'"); + }); + + test('generated file contains viewModel types', () => { + const content = readFileSync(OUT_DTS, 'utf8'); + expect(content).toContain("'Rewards'"); + expect(content).toContain("'viewModel:Item_Icon_Value'"); + }); + + test('generated file has eslint-disable header', () => { + const content = readFileSync(OUT_DTS, 'utf8'); + expect(content).toContain('eslint-disable'); + }); +}); diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts new file mode 100644 index 00000000..16311ffe --- /dev/null +++ b/scripts/rive-extract-schema.ts @@ -0,0 +1,105 @@ +#!/usr/bin/env bun +/** + * Extracts artboard names and state machines from a .riv file and prints JSON to stdout. + * + * Usage: + * bun scripts/rive-extract-schema.ts path/to/file.riv + * bun scripts/rive-extract-schema.ts https://example.com/file.riv + * + * Output: { "artboards": ["Main", "Intro"], "stateMachines": { "Main": ["State Machine 1"], "Intro": ["Idle"] } } + */ + +import { readFileSync } from 'fs'; +import { RuntimeLoader } from '@rive-app/canvas'; + +// noUncheckedIndexedAccess: process.argv destructuring yields string | undefined +const input: string | undefined = process.argv[2]; + +// @rive-app/canvas checks for browser globals during WASM initialisation. +// We only call file-inspection APIs (no rendering), so minimal shims are enough. +(globalThis as any).document = { createElement: () => ({ getContext: () => null }) }; +(globalThis as any).Image = class {}; + +// The WASM runtime prints warnings (e.g. "No WebGL support") via console. +// Redirect them to stderr so our JSON output stays clean. +console.log = (...args: unknown[]) => process.stderr.write(args.join(' ') + '\n'); +console.warn = (...args: unknown[]) => process.stderr.write(args.join(' ') + '\n'); + +if (!input) { + process.stderr.write('Usage: bun rive-extract-schema.ts \n'); + process.exit(1); +} +const source: string = input; + +async function loadBytes(source: string): Promise { + if (source.startsWith('http://') || source.startsWith('https://')) { + const res = await fetch(source); + if (!res.ok) throw new Error(`HTTP ${res.status}: ${source}`); + return new Uint8Array(await res.arrayBuffer()); + } + return new Uint8Array(readFileSync(source)); +} + +async function main() { + const bytes = await loadBytes(source); + const runtime = await RuntimeLoader.awaitInstance(); + + // Stub image loading: call la() (the "loaded" callback) immediately so + // runtime.load() resolves without waiting for CDN asset fetches. + const origMRI = (runtime.renderFactory as any).makeRenderImage.bind( + runtime.renderFactory + ); + (runtime.renderFactory as any).makeRenderImage = function () { + const img = origMRI(); + queueMicrotask(() => img.la()); + return img; + }; + + const riveFile = await runtime.load(bytes, undefined, false); + + const artboards: string[] = []; + const stateMachines: Record = {}; + for (let i = 0; i < riveFile.artboardCount(); i++) { + const artboard = riveFile.artboardByIndex(i); + artboards.push(artboard.name); + const sms: string[] = []; + for (let j = 0; j < artboard.stateMachineCount(); j++) { + sms.push(artboard.stateMachineByIndex(j).name); + } + stateMachines[artboard.name] = sms; + } + + const viewModels: Record> = {}; + const vmCount = (riveFile as any).viewModelCount() as number; + for (let i = 0; i < vmCount; i++) { + const vm = (riveFile as any).viewModelByIndex(i); + const properties = vm.getProperties() as Array<{ name: string; type: string }>; + // Create a blank instance to resolve viewModel property references + const inst = vm.instance?.() as any; + const props: Record = {}; + for (const p of properties) { + if (p.type === 'viewModel' && inst) { + try { + const nested = inst.viewModel?.(p.name); + const refName = nested?.getViewModelName?.(); + props[p.name] = refName ? `viewModel:${refName}` : 'viewModel'; + } catch { + props[p.name] = 'viewModel'; + } + } else { + props[p.name] = p.type; + } + } + viewModels[vm.name] = props; + } + + const defaultArtboard = artboards[0] ?? ''; + process.stdout.write( + JSON.stringify({ artboards, defaultArtboard, stateMachines, viewModels }, null, 2) + '\n' + ); +} + +main().catch((err: Error) => { + process.stderr.write(err.message + '\n'); + process.exit(1); +}); diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts new file mode 100644 index 00000000..ba30bb12 --- /dev/null +++ b/scripts/rive-gen-types.ts @@ -0,0 +1,189 @@ +#!/usr/bin/env bun +/** + * Generates .riv.d.ts declaration files so that `import asset from './file.riv'` + * is automatically typed in TypeScript without any extra imports. + * + * Usage: + * bun scripts/rive-gen-types.ts # writes .riv.d.ts next to the source + * bun scripts/rive-gen-types.ts --out # write a standalone schema .ts instead + * bun scripts/rive-gen-types.ts --all # generate for every .riv in a directory + * + * After generation, TypeScript resolves the .riv.d.ts automatically: + * import gameRiv from './assets/game.riv'; // typed as RiveAsset + * const file = await RiveFileFactory.fromSource(gameRiv); // TypedRiveFile — T inferred + */ + +import { execSync } from 'child_process'; +import { writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'; +import { dirname, resolve, basename, extname } from 'path'; +import { fileURLToPath } from 'url'; + +const __dirname = dirname(fileURLToPath(import.meta.url)); +const extractorPath = resolve(__dirname, 'rive-extract-schema.ts'); + +interface Schema { + artboards: string[]; + defaultArtboard: string; + stateMachines: Record; + viewModels: Record>; +} + +function extractSchema(input: string): Schema { + for (let attempt = 0; attempt < 2; attempt++) { + try { + const json = execSync(`bun "${extractorPath}" "${input}"`, { encoding: 'utf8', timeout: 30_000 }); + return JSON.parse(json) as Schema; + } catch (err) { + if (attempt === 1) throw err; + } + } + throw new Error('unreachable'); +} + +function smRecord(stateMachines: Record): string { + return Object.entries(stateMachines) + .map(([ab, sms]) => { + const union = sms.length ? sms.map((s) => `'${s}'`).join(' | ') : 'never'; + return ` '${ab}': ${union};`; + }) + .join('\n'); +} + +function vmRecord(viewModels: Record>): string { + return Object.entries(viewModels) + .map(([vmName, props]) => { + const propLines = Object.entries(props) + .map(([propName, propType]) => ` '${propName}': '${propType}';`) + .join('\n'); + return ` '${vmName}': {\n${propLines}\n };`; + }) + .join('\n'); +} + +function schemaBody(schema: Schema): string { + const vmSection = + Object.keys(schema.viewModels).length > 0 + ? `\n viewModels: {\n${vmRecord(schema.viewModels)}\n };` + : ''; + return `\ + artboards: ${schema.artboards.map((a) => `'${a}'`).join(' | ')}; + defaultArtboard: '${schema.defaultArtboard}'; + stateMachines: { +${smRecord(schema.stateMachines)} + };${vmSection}`; +} + +function dtsContent(input: string, schema: Schema): string { + return `\ +// Generated by rive-gen-types — do not edit manually. @generated +// eslint-disable +// Source: ${basename(input)} +import type { RiveAsset } from '@rive-app/react-native'; +declare const asset: RiveAsset<{ +${schemaBody(schema)} +}>; +export default asset; +`; +} + +function standaloneContent(input: string, typeName: string, schema: Schema): string { + return `\ +// Generated by rive-gen-types — do not edit manually. +// Source: ${input} +import type { RiveFileSchema } from '@rive-app/react-native'; + +export type ${typeName} = RiveFileSchema & { +${schemaBody(schema)} +}; +`; +} + +function generate(input: string, outPath: string, mode: 'dts' | 'standalone', typeName?: string) { + let schema: Schema; + try { + schema = extractSchema(input); + } catch (err) { + process.stderr.write( + `Failed to extract schema from ${input}: ${err instanceof Error ? err.message : String(err)}\n` + ); + process.exit(1); + } + + if (!schema.artboards?.length) { + process.stderr.write(`No artboards found in ${input}.\n`); + process.exit(1); + } + + const content = + mode === 'dts' + ? dtsContent(input, schema) + : standaloneContent(input, typeName!, schema); + + mkdirSync(dirname(outPath), { recursive: true }); + writeFileSync(outPath, content, 'utf8'); + process.stdout.write(`Written: ${outPath}\n`); +} + +function findRivFiles(dir: string): string[] { + const results: string[] = []; + for (const entry of readdirSync(dir)) { + const full = resolve(dir, entry); + if (statSync(full).isDirectory()) { + results.push(...findRivFiles(full)); + } else if (extname(entry) === '.riv') { + results.push(full); + } + } + return results; +} + +// --- CLI --- + +// noUncheckedIndexedAccess: slice gives string[], index access gives string | undefined +const args: string[] = process.argv.slice(2); + +if (args[0] === '--all') { + const dir: string | undefined = args[1]; + if (!dir) { + process.stderr.write('Usage: rive-gen-types --all \n'); + process.exit(1); + } + const files = findRivFiles(resolve(process.cwd(), dir)); + if (!files.length) { + process.stderr.write(`No .riv files found in ${dir}\n`); + process.exit(1); + } + for (const file of files) { + generate(file, `${file}.d.ts`, 'dts'); + } + process.exit(0); +} + +if (!args.length || args[0]!.startsWith('--')) { + process.stderr.write( + 'Usage:\n' + + ' rive-gen-types # writes .riv.d.ts\n' + + ' rive-gen-types --out # standalone schema .ts\n' + + ' rive-gen-types --all # all .riv files in dir\n' + ); + process.exit(1); +} + +const input = args[0]!; +const outIdx = args.indexOf('--out'); + +if (outIdx !== -1) { + // Standalone mode: generate a named schema type, not a .d.ts + const outPath = resolve(process.cwd(), args[outIdx + 1]!); + const baseName = basename(input, '.riv').replace(/[^a-zA-Z0-9]/g, '_'); + const nameIdx = args.indexOf('--name'); + const typeName = + nameIdx !== -1 + ? args[nameIdx + 1]! + : baseName.charAt(0).toUpperCase() + baseName.slice(1) + 'Schema'; + generate(input, outPath, 'standalone', typeName); +} else { + // Default: write .riv.d.ts next to the source file + const absInput = resolve(process.cwd(), input); + generate(input, `${absInput}.d.ts`, 'dts'); +} diff --git a/src/__tests__/typed-rive.test-d.ts b/src/__tests__/typed-rive.test-d.ts new file mode 100644 index 00000000..0dc3adda --- /dev/null +++ b/src/__tests__/typed-rive.test-d.ts @@ -0,0 +1,207 @@ +import { expectType, expectError, expectAssignable } from 'tsd'; +import type { TypedRiveFile, RiveAsset } from '../../src/core/TypedRiveFile'; +import type { TypedViewModelInstance } from '../../src/core/TypedViewModelInstance'; +import type { + ViewModelNumberProperty, + ViewModelTriggerProperty, + ViewModelBooleanProperty, +} from '../../src/specs/ViewModel.nitro'; +import type { TypedViewModelListProperty } from '../../src/core/TypedViewModelInstance'; +import type { RiveViewProps } from '../../src/core/RiveView'; +import gradientBorderRiv from '../../example/assets/rive/GradientBorder.riv'; +import blinkoRiv from '../../example/assets/rive/blinko.riv'; + +// Infer schemas from the generated .riv.d.ts assets +type GradientBorderSchema = typeof gradientBorderRiv extends RiveAsset + ? T + : never; +type BlinkoSchema = typeof blinkoRiv extends RiveAsset ? T : never; + +declare const gradientFile: TypedRiveFile; +declare const blinkoFile: TypedRiveFile; +declare const untypedFile: TypedRiveFile; + +// --- TypedRiveFile assignability --- + +// Typed files are assignable to the untyped base (backward compat) +expectAssignable(gradientFile); +expectAssignable(blinkoFile); + +// --- Single-artboard: artboardName constraints --- + +expectAssignable>({ + file: gradientFile, + artboardName: 'Layout', +}); + +// Wrong artboard name must error +expectError>({ + file: gradientFile, + artboardName: 'NotAnArtboard', +}); + +// --- Single-artboard: stateMachineName constraints --- + +expectAssignable>({ + file: gradientFile, + stateMachineName: 'State', +}); + +// Wrong SM name must error +expectError>({ + file: gradientFile, + stateMachineName: 'NonexistentSM', +}); + +// --- Multi-artboard: default artboard (A not specified) --- +// When artboardName is not specified, A defaults to defaultArtboard ('Main'). +// artboardName must be 'Main' (or undefined), stateMachineName constrained to Main's SMs. + +expectAssignable>({ + file: blinkoFile, + artboardName: 'Main', + stateMachineName: 'State Machine 1', +}); + +expectAssignable>({ + file: blinkoFile, + stateMachineName: 'State Machine 1', +}); + +// Non-default artboard without explicit A type parameter must error +expectError>({ + file: blinkoFile, + artboardName: 'StoreItem', +}); + +// Invalid SM on default artboard must error +expectError>({ + file: blinkoFile, + stateMachineName: 'Nonexistent SM', +}); + +// --- Multi-artboard: explicit non-default artboard (A specified) --- +// Specifying A constrains artboardName and stateMachineName to that artboard. + +expectAssignable>({ + file: blinkoFile, + artboardName: 'StoreItem', + stateMachineName: 'State Machine 1', +}); + +// Wrong artboard when A = 'StoreItem' must error +expectError>({ + file: blinkoFile, + artboardName: 'Puck', +}); + +// Wrong SM when A = 'StoreItem' must error +expectError>({ + file: blinkoFile, + artboardName: 'StoreItem', + stateMachineName: 'Nonexistent SM', +}); + +// --- Untyped file: accepts any string (backward compat) --- + +expectAssignable({ + file: untypedFile, + artboardName: 'anything', + stateMachineName: 'anything', +}); + +// --- RiveAsset branding --- + +declare const gradientAsset: RiveAsset; + +// RiveAsset is a branded number +expectType( + gradientAsset +); + +// RiveAsset with wrong schema is not assignable to a different typed asset +expectError>(gradientAsset); + +// ============================================================ +// TypedViewModelInstance +// ============================================================ + +// Blinko storeVM: xbuttonClick:trigger, multiplierValue:number, +// storeOpen:boolean, 'property of pegVM':viewModel:pegVM +// pegVM: blink:trigger, multiplierValue:number, pegType:enumType + +type StoreVMInstance = TypedViewModelInstance; +type PegVMInstance = TypedViewModelInstance; + +declare const storeVM: StoreVMInstance; + +// --- Direct property access --- + +// Valid number property +expectAssignable( + storeVM.numberProperty('multiplierValue') +); + +// Valid trigger property +expectAssignable( + storeVM.triggerProperty('xbuttonClick') +); + +// Valid boolean property +expectAssignable( + storeVM.booleanProperty('storeOpen') +); + +// Wrong kind: xbuttonClick is 'trigger', not 'number' +expectError(storeVM.numberProperty('xbuttonClick')); + +// Nonexistent property name must error +expectError(storeVM.numberProperty('doesNotExist')); + +// --- Nested viewModel access --- + +// Accessing a viewModel reference returns the correct typed instance +expectAssignable( + storeVM.viewModel('property of pegVM') +); + +// Non-viewModel property name is rejected for viewModel() +expectError(storeVM.viewModel('xbuttonClick')); + +// Nonexistent path is rejected +expectError(storeVM.viewModel('notAProperty')); + +// --- Chained nested access --- + +// storeVM → pegVM → pegVM.numberProperty('multiplierValue') +expectAssignable( + storeVM.viewModel('property of pegVM')?.numberProperty('multiplierValue') +); + +// storeVM → pegVM → wrong property kind errors +expectError( + storeVM.viewModel('property of pegVM')?.numberProperty('blink') +); + +// storeVM → pegVM → nonexistent property errors +expectError( + storeVM.viewModel('property of pegVM')?.stringProperty('doesNotExist') +); + +// --- List property --- + +// storeVM.items is a 'list' — returns a typed list property +expectAssignable | undefined>( + storeVM.listProperty('items') +); + +// Non-list property rejected for listProperty() +expectError(storeVM.listProperty('xbuttonClick')); + +// List element is a union of all file ViewModels (any one of them) +type AnyBlinkoVM = TypedViewModelInstance< + BlinkoSchema, + Extract +>; +declare const list: TypedViewModelListProperty; +expectAssignable>(list.getInstanceAtAsync(0)); diff --git a/src/core/RiveFile.ts b/src/core/RiveFile.ts index ba8e873f..cfc44c54 100644 --- a/src/core/RiveFile.ts +++ b/src/core/RiveFile.ts @@ -1,8 +1,6 @@ import { NitroModules } from 'react-native-nitro-modules'; -import type { - RiveFile, - RiveFileFactory as RiveFileFactoryInternal, -} from '../specs/RiveFile.nitro'; +import type { RiveFileFactory as RiveFileFactoryInternal } from '../specs/RiveFile.nitro'; +import type { RiveAsset, RiveFileSchema, TypedRiveFile } from './TypedRiveFile'; import { Image } from 'react-native'; import type { ResolvedReferencedAssets } from './ReferencedAssets'; @@ -15,76 +13,52 @@ const RiveFileInternal = * Provides static methods to load Rive files from URLs, resources, or raw bytes. */ export namespace RiveFileFactory { - /** - * Creates a RiveFile instance from a URL. - * @param url - The URL of the Rive (.riv) file - * @param loadCdn - Whether to load from CDN (default: true) - * @returns Promise that resolves to a RiveFile instance - */ - export async function fromURL( + export async function fromURL( url: string, referencedAssets: ResolvedReferencedAssets | undefined, loadCdn: boolean = true - ): Promise { + ): Promise> { return RiveFileInternal.fromURL( url, loadCdn, referencedAssets ? { data: referencedAssets } : undefined - ); + ) as Promise>; } - /** - * Creates a RiveFile instance from a local file path URL. - * @param pathURL - The local file path of the Rive (.riv) file - * @param loadCdn - Whether to load from CDN (default: true) - * @returns Promise that resolves to a RiveFile instance - */ - export async function fromFileURL( + export async function fromFileURL( fileURL: string, referencedAssets: ResolvedReferencedAssets | undefined = undefined, loadCdn: boolean = true - ): Promise { + ): Promise> { return RiveFileInternal.fromFileURL( fileURL, loadCdn, referencedAssets ? { data: referencedAssets } : undefined - ); + ) as Promise>; } - /** - * Creates a RiveFile instance from a local resource. - * @param resource - The name of the local resource - * @param loadCdn - Whether to load from CDN (default: true) - * @returns Promise that resolves to a RiveFile instance - */ - export async function fromResource( + export async function fromResource( resource: string, referencedAssets: ResolvedReferencedAssets | undefined, loadCdn: boolean = true - ): Promise { + ): Promise> { return RiveFileInternal.fromResource( resource, loadCdn, referencedAssets ? { data: referencedAssets } : undefined - ); + ) as Promise>; } - /** - * Creates a RiveFile instance from raw bytes. - * @param bytes - The raw bytes of the Rive (.riv) file - * @param loadCdn - Whether to load from CDN (default: true) - * @returns Promise that resolves to a RiveFile instance - */ - export async function fromBytes( + export async function fromBytes( bytes: ArrayBuffer, referencedAssets: ResolvedReferencedAssets | undefined, loadCdn: boolean = true - ): Promise { + ): Promise> { return RiveFileInternal.fromBytes( bytes, loadCdn, referencedAssets ? { data: referencedAssets } : undefined - ); + ) as Promise>; } /** @@ -109,11 +83,11 @@ export namespace RiveFileFactory { * config.resolver.assetExts = [...config.resolver.assetExts, 'riv']; * ``` */ - export async function fromSource( - source: number | { uri: string }, + export async function fromSource( + source: RiveAsset | { uri: string }, referencedAssets: ResolvedReferencedAssets | undefined, loadCdn: boolean = true - ): Promise { + ): Promise> { const assetID = typeof source === 'number' ? source : null; const sourceURI = typeof source === 'object' ? source.uri : null; @@ -130,16 +104,16 @@ export namespace RiveFileFactory { try { // handle http address and dev server if (assetURI.match(/https?:\/\//)) { - return RiveFileFactory.fromURL(assetURI, referencedAssets, loadCdn); + return RiveFileFactory.fromURL(assetURI, referencedAssets, loadCdn); } // handle iOS bundled asset if (assetURI.match(/file:\/\//)) { - return RiveFileFactory.fromFileURL(assetURI, referencedAssets, loadCdn); + return RiveFileFactory.fromFileURL(assetURI, referencedAssets, loadCdn); } // handle Android bundled asset or resource name uri - return RiveFileFactory.fromResource(assetURI, referencedAssets, loadCdn); + return RiveFileFactory.fromResource(assetURI, referencedAssets, loadCdn); } catch (error: unknown) { const errorMessage = error instanceof Error ? error.message : String(error); diff --git a/src/core/RiveView.tsx b/src/core/RiveView.tsx index f7bd16f3..7b2b7adf 100644 --- a/src/core/RiveView.tsx +++ b/src/core/RiveView.tsx @@ -3,48 +3,32 @@ import { NitroRiveView } from './NitroRiveViewComponent'; import { RiveErrorType, type RiveError } from './Errors'; import { callDispose } from './callDispose'; import type { RiveViewRef } from '../index'; +import type { RiveFileSchema, TypedRiveFile } from './TypedRiveFile'; -export interface RiveViewProps extends Omit< - ComponentProps, - 'onError' -> { +type NitroRiveViewProps = ComponentProps; + +export interface RiveViewProps< + T extends RiveFileSchema = RiveFileSchema, + A extends T['artboards'] = T['defaultArtboard'] +> extends Omit { onError?: (error: RiveError) => void; + file: TypedRiveFile; + /** Name of the artboard to display. When using a generated schema, only valid artboard names are accepted. */ + artboardName?: A; + /** + * Name of the state machine to play. + * Constrained to the selected artboard's state machines, or the default artboard's if none is specified. + */ + stateMachineName?: T['stateMachines'][A]; } const defaultOnError = (error: RiveError) => console.error(`[${RiveErrorType[error.type]}] ${error.message}`); -/** - * RiveView is a React Native component that renders Rive graphics. - * It provides a seamless way to display and control Rive graphics in your app. - * - * @example - * ```tsx - * - * ``` - * - * @property {RiveFile} file - The Rive file to be displayed - * @property {string} [artboardName] - Name of the artboard to display from the Rive file - * @property {string} [stateMachineName] - Name of the state machine to play - * @property {ViewModelInstance | DataBindMode | DataBindByName} [dataBind] - Data binding configuration for the state machine, defaults to DataBindMode.Auto - * @property {boolean} [autoPlay=true] - Whether to automatically start playing the state machine - * @property {Alignment} [alignment] - How the Rive graphic should be aligned within its container - * @property {Fit} [fit] - How the Rive graphic should fit within its container - * @property {Object} [style] - React Native style object for container customization - * @property {(error: RiveError) => void} [onError] - Callback function that is called when an error occurs - * - * The component also exposes methods for controlling playback: - * - play(): Starts playing the Rive graphic - * - pause(): Pauses the Rive graphic - */ -export function RiveView(props: RiveViewProps) { +export function RiveView< + T extends RiveFileSchema = RiveFileSchema, + A extends T['artboards'] = T['defaultArtboard'] +>(props: RiveViewProps) { const { onError, hybridRef: userHybridRef, ...rest } = props; const wrappedOnError = onError ?? defaultOnError; const viewRef = useRef(null); diff --git a/src/core/TypedRiveFile.ts b/src/core/TypedRiveFile.ts new file mode 100644 index 00000000..6aefc5b2 --- /dev/null +++ b/src/core/TypedRiveFile.ts @@ -0,0 +1,43 @@ +import type { RiveFile } from '../specs/RiveFile.nitro'; + +/** + * Describes the statically-known shape of a .riv file. + * Extend this interface via generated schema files to get type-safe artboard names. + * + * @example Generated by: yarn rive-gen-types path/to/file.riv + * ```ts + * export type MySchema = RiveFileSchema & { + * artboards: 'Main' | 'Intro' | 'GameOver'; + * }; + * ``` + */ +export interface RiveFileSchema { + artboards: string; + defaultArtboard: string; + stateMachines: Record; + viewModels: Record>; +} + +/** + * A Metro asset (number) branded with a schema type `T`. + * The `__riveSchema` field is purely phantom — it never exists at runtime. + * + * Created automatically when you `import asset from './file.riv'` and a + * corresponding `file.riv.d.ts` has been generated by `yarn rive-gen-types`. + * + * Pass to `RiveFileFactory.fromSource(asset)` — TypeScript infers `T` automatically. + */ +export type RiveAsset = number & { + readonly __riveSchema?: T; +}; + +/** + * A RiveFile branded with a schema type `T`. + * The `__schema` field is purely a phantom type — it never exists at runtime. + * + * Obtain one via `RiveFileFactory.fromURL(...)` or + * `RiveFileFactory.fromSource(typedAsset)`. + */ +export type TypedRiveFile = RiveFile & { + readonly __schema?: T; +}; diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts new file mode 100644 index 00000000..365904fb --- /dev/null +++ b/src/core/TypedViewModelInstance.ts @@ -0,0 +1,152 @@ +import type { + ViewModelInstance, + ViewModelNumberProperty, + ViewModelStringProperty, + ViewModelBooleanProperty, + ViewModelColorProperty, + ViewModelTriggerProperty, + ViewModelEnumProperty, + ViewModelImageProperty, + ViewModelListProperty, +} from '../specs/ViewModel.nitro'; +import type { RiveFileSchema } from './TypedRiveFile'; + +/** + * A typed list property whose elements are ViewModelInstances from the same file. + * Elements can be any ViewModel defined in the file — the exact type is unknown + * until runtime, so the element type is a union of all file ViewModels. + */ +export interface TypedViewModelListProperty + extends Omit { + getInstanceAtAsync( + index: number + ): Promise< + TypedViewModelInstance> | undefined + >; + /** @deprecated Use getInstanceAtAsync instead */ + getInstanceAt( + index: number + ): TypedViewModelInstance> | undefined; +} + +/** Property names whose type literal matches the given Kind */ +export type VMPropsOfKind< + VM extends Record, + Kind extends string, +> = { + [K in keyof VM]: VM[K] extends Kind ? K : never; +}[keyof VM] & + string; + +/** Extract the referenced ViewModel name from 'viewModel:SomeName' */ +export type VMRefName = + TypeStr extends `viewModel:${infer Name}` ? Name : never; + +/** Property names that are viewModel references (type = 'viewModel:*') */ +export type VMRefPropNames> = { + [K in keyof VM]: VM[K] extends `viewModel:${string}` ? K : never; +}[keyof VM] & + string; + +/** Resolved ViewModel name for a nested viewModel reference property */ +type VMRefNameResolved< + T extends RiveFileSchema, + VMName extends keyof T['viewModels'] & string, + P extends keyof T['viewModels'][VMName], +> = VMRefName & + Extract; + +type NestedPathsOfKind< + T extends RiveFileSchema, + VMName extends keyof T['viewModels'] & string, + Kind extends string, +> = { + [P in VMRefPropNames]: `${P}/${VMPropsOfKind], Kind>}`; +}[VMRefPropNames]; + +/** + * All valid property paths of a given kind, including one level of nested ViewModel paths. + * Direct paths: `'Price_Value'` + * Nested paths: `'Coin/Item_Value'` + */ +export type PathsOfKind< + T extends RiveFileSchema, + VMName extends keyof T['viewModels'] & string, + Kind extends string, +> = + | VMPropsOfKind + | NestedPathsOfKind; + +/** + * A ViewModelInstance typed to a specific ViewModel schema entry. + * Property accessor methods are constrained to valid property names. + * `.viewModel(path)` returns a TypedViewModelInstance for the referenced ViewModel. + * + * Obtain via `useViewModelInstance(typedFile, { viewModelName: 'MyVM' })`. + */ +export interface TypedViewModelInstance< + T extends RiveFileSchema, + VMName extends keyof T['viewModels'] & string, +> extends Omit< + ViewModelInstance, + | 'numberProperty' + | 'stringProperty' + | 'booleanProperty' + | 'colorProperty' + | 'triggerProperty' + | 'enumProperty' + | 'imageProperty' + | 'listProperty' + | 'viewModel' + | 'viewModelAsync' + > { + numberProperty( + path: VMPropsOfKind + ): ViewModelNumberProperty | undefined; + + stringProperty( + path: VMPropsOfKind + ): ViewModelStringProperty | undefined; + + booleanProperty( + path: VMPropsOfKind + ): ViewModelBooleanProperty | undefined; + + colorProperty( + path: VMPropsOfKind + ): ViewModelColorProperty | undefined; + + triggerProperty( + path: VMPropsOfKind + ): ViewModelTriggerProperty | undefined; + + enumProperty( + path: VMPropsOfKind + ): ViewModelEnumProperty | undefined; + + imageProperty( + path: VMPropsOfKind + ): ViewModelImageProperty | undefined; + + listProperty( + path: VMPropsOfKind + ): TypedViewModelListProperty | undefined; + + /** Access a nested ViewModel instance; return type is typed to the referenced ViewModel. */ + viewModel

>( + path: P + ): TypedViewModelInstance< + T, + VMRefName & keyof T['viewModels'] & string + > | undefined; + + viewModelAsync

>( + path: P + ): Promise< + | TypedViewModelInstance< + T, + VMRefName & keyof T['viewModels'] & string + > + | undefined + >; +} diff --git a/src/hooks/useRiveBoolean.ts b/src/hooks/useRiveBoolean.ts index 657d9ad6..f551b8de 100644 --- a/src/hooks/useRiveBoolean.ts +++ b/src/hooks/useRiveBoolean.ts @@ -4,6 +4,8 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; +import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; const getBooleanProperty = (vmi: ViewModelInstance, p: string) => vmi.booleanProperty(p); @@ -15,6 +17,17 @@ const getBooleanProperty = (vmi: ViewModelInstance, p: string) => * @param viewModelInstance - The ViewModelInstance containing the boolean property to operate on * @returns An object with the boolean value, a setter function, and an error if the property is not found */ +export function useRiveBoolean< + T extends RiveFileSchema, + N extends Extract, +>( + path: PathsOfKind, + viewModelInstance?: TypedViewModelInstance | null +): UseRivePropertyResult; +export function useRiveBoolean( + path: string, + viewModelInstance?: ViewModelInstance | null +): UseRivePropertyResult; export function useRiveBoolean( path: string, viewModelInstance?: ViewModelInstance | null diff --git a/src/hooks/useRiveColor.ts b/src/hooks/useRiveColor.ts index bd6ce38e..9e9ccf34 100644 --- a/src/hooks/useRiveColor.ts +++ b/src/hooks/useRiveColor.ts @@ -5,6 +5,8 @@ import type { } from '../specs/ViewModel.nitro'; import { useRiveProperty } from './useRiveProperty'; import { RiveColor } from '../core/RiveColor'; +import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; const getColorProperty = (vmi: ViewModelInstance, p: string) => vmi.colorProperty(p); @@ -22,6 +24,17 @@ export interface UseRiveColorResult { * @param viewModelInstance - The ViewModelInstance containing the color property to operate on * @returns An object with the color value as RGBA, a setter function that accepts either RGBA or hex string, and an error if the property is not found */ +export function useRiveColor< + T extends RiveFileSchema, + N extends Extract, +>( + path: PathsOfKind, + viewModelInstance?: TypedViewModelInstance | null +): UseRiveColorResult; +export function useRiveColor( + path: string, + viewModelInstance?: ViewModelInstance | null +): UseRiveColorResult; export function useRiveColor( path: string, viewModelInstance?: ViewModelInstance | null diff --git a/src/hooks/useRiveFile.ts b/src/hooks/useRiveFile.ts index b9d5d83e..5a030fc2 100644 --- a/src/hooks/useRiveFile.ts +++ b/src/hooks/useRiveFile.ts @@ -12,6 +12,7 @@ import type { ReferencedAssets, ResolvedReferencedAssets, } from '../core/ReferencedAssets'; +import type { RiveAsset, RiveFileSchema, TypedRiveFile } from '../core/TypedRiveFile'; export type { ReferencedAssets, ResolvedReferencedAssets }; export type RiveFileInput = number | { uri: string } | string | ArrayBuffer; @@ -92,6 +93,17 @@ export type UseRiveFileResult = | { riveFile: null; isLoading: false; error: Error } | { riveFile: undefined; isLoading: true; error: null }; +export function useRiveFile( + input: RiveAsset, + options?: UseRiveFileOptions +): + | { riveFile: TypedRiveFile; isLoading: false; error: null } + | { riveFile: null; isLoading: false; error: Error } + | { riveFile: undefined; isLoading: true; error: null }; +export function useRiveFile( + input: RiveFileInput | undefined, + options?: UseRiveFileOptions +): UseRiveFileResult; export function useRiveFile( input: RiveFileInput | undefined, options: UseRiveFileOptions = {} diff --git a/src/hooks/useRiveNumber.ts b/src/hooks/useRiveNumber.ts index 773d30e2..aacd55a4 100644 --- a/src/hooks/useRiveNumber.ts +++ b/src/hooks/useRiveNumber.ts @@ -4,6 +4,8 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; +import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; const getNumberProperty = (vmi: ViewModelInstance, p: string) => vmi.numberProperty(p); @@ -15,6 +17,17 @@ const getNumberProperty = (vmi: ViewModelInstance, p: string) => * @param viewModelInstance - The ViewModelInstance containing the number property to operate on * @returns An object with the number value, a setter function, and an error if the property is not found */ +export function useRiveNumber< + T extends RiveFileSchema, + N extends Extract, +>( + path: PathsOfKind, + viewModelInstance?: TypedViewModelInstance | null +): UseRivePropertyResult; +export function useRiveNumber( + path: string, + viewModelInstance?: ViewModelInstance | null +): UseRivePropertyResult; export function useRiveNumber( path: string, viewModelInstance?: ViewModelInstance | null diff --git a/src/hooks/useRiveString.ts b/src/hooks/useRiveString.ts index e182ddff..aab4980d 100644 --- a/src/hooks/useRiveString.ts +++ b/src/hooks/useRiveString.ts @@ -4,6 +4,8 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; +import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; const getStringProperty = (vmi: ViewModelInstance, p: string) => vmi.stringProperty(p); @@ -15,6 +17,17 @@ const getStringProperty = (vmi: ViewModelInstance, p: string) => * @param viewModelInstance - The ViewModelInstance containing the string property to operate on * @returns An object with the number value, a setter function, and an error if the property is not found */ +export function useRiveString< + T extends RiveFileSchema, + N extends Extract, +>( + path: PathsOfKind, + viewModelInstance?: TypedViewModelInstance | null +): UseRivePropertyResult; +export function useRiveString( + path: string, + viewModelInstance?: ViewModelInstance | null +): UseRivePropertyResult; export function useRiveString( path: string, viewModelInstance?: ViewModelInstance | null diff --git a/src/hooks/useRiveTrigger.ts b/src/hooks/useRiveTrigger.ts index 8f8315c9..7ab354eb 100644 --- a/src/hooks/useRiveTrigger.ts +++ b/src/hooks/useRiveTrigger.ts @@ -8,6 +8,8 @@ import type { UseViewModelInstanceTriggerParameters, } from '../types'; import { useDisposableMemo } from './useDisposableMemo'; +import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; /** * Hook for interacting with trigger ViewModel instance properties. @@ -21,6 +23,19 @@ import { useDisposableMemo } from './useDisposableMemo'; * @param params - Optional parameters including onTrigger callback * @returns A trigger function and any error */ +export function useRiveTrigger< + T extends RiveFileSchema, + N extends Extract, +>( + path: PathsOfKind, + viewModelInstance?: TypedViewModelInstance | null, + params?: UseViewModelInstanceTriggerParameters +): UseRiveTriggerResult; +export function useRiveTrigger( + path: string, + viewModelInstance?: ViewModelInstance | null, + params?: UseViewModelInstanceTriggerParameters +): UseRiveTriggerResult; export function useRiveTrigger( path: string, viewModelInstance?: ViewModelInstance | null, diff --git a/src/hooks/useViewModelInstance.ts b/src/hooks/useViewModelInstance.ts index f5acea77..a25d0f85 100644 --- a/src/hooks/useViewModelInstance.ts +++ b/src/hooks/useViewModelInstance.ts @@ -3,6 +3,8 @@ import { useMemo, useRef } from 'react'; import type { ViewModel, ViewModelInstance } from '../specs/ViewModel.nitro'; import type { RiveFile } from '../specs/RiveFile.nitro'; +import type { RiveFileSchema, TypedRiveFile } from '../core/TypedRiveFile'; +import type { TypedViewModelInstance } from '../core/TypedViewModelInstance'; import type { RiveViewRef } from '../index'; import { callDispose } from '../core/callDispose'; import { ArtboardByName } from '../specs/ArtboardBy'; @@ -263,6 +265,18 @@ export type UseViewModelInstanceResult = * if (error) console.error(error.message); * ``` */ +// Typed overload: TypedRiveFile + literal viewModelName → TypedViewModelInstance +export function useViewModelInstance< + T extends RiveFileSchema, + N extends Extract, +>( + source: TypedRiveFile | null | undefined, + params: UseViewModelInstanceFileParams & { viewModelName: N } +): { + instance: TypedViewModelInstance | null | undefined; + error: Error | null; +}; + // RiveFile overloads export function useViewModelInstance( source: RiveFile, diff --git a/src/index.tsx b/src/index.tsx index 7e29e27a..7f5183ef 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -20,6 +20,8 @@ export { RiveView, type RiveViewProps } from './core/RiveView'; export type { RiveViewMethods }; export type RiveViewRef = HybridView; export type { RiveFile } from './specs/RiveFile.nitro'; +export type { RiveAsset, RiveFileSchema, TypedRiveFile } from './core/TypedRiveFile'; +export type { TypedViewModelInstance, TypedViewModelListProperty, PathsOfKind } from './core/TypedViewModelInstance'; export type { ViewModel, ViewModelInstance, diff --git a/tsconfig.json b/tsconfig.json index 278a9b8f..6b0104c0 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -26,5 +26,5 @@ "target": "ESNext", "verbatimModuleSyntax": true }, - "exclude": ["expo-example", "expo55-example"] + "exclude": ["expo-example", "expo55-example", "**/*.test-d.ts", "scripts/__tests__"] } diff --git a/yarn.lock b/yarn.lock index d8986822..f95ed8cc 100644 --- a/yarn.lock +++ b/yarn.lock @@ -5459,6 +5459,13 @@ __metadata: languageName: node linkType: hard +"@rive-app/canvas@npm:^2.38.0": + version: 2.38.0 + resolution: "@rive-app/canvas@npm:2.38.0" + checksum: a75508c461db26c48d3d3daebd9bd2b1a28fd528062640bd99f767f3b0fc32a518e3bffaadccbab93b3819c7f1225f7d1c65e1534c036798482cf271b5d61161 + languageName: node + linkType: hard + "@rive-app/react-native@workspace:.": version: 0.0.0-use.local resolution: "@rive-app/react-native@workspace:." @@ -5470,6 +5477,7 @@ __metadata: "@react-native/babel-preset": 0.79.2 "@react-native/eslint-config": ^0.78.0 "@release-it/conventional-changelog": ^9.0.2 + "@rive-app/canvas": ^2.38.0 "@testing-library/react-hooks": ^8.0.1 "@testing-library/react-native": ^13.3.3 "@types/jest": ^29.5.5 @@ -5492,6 +5500,7 @@ __metadata: react-native-nitro-modules: 0.35.0 react-test-renderer: 19.0.0 release-it: ^17.10.0 + tsd: ^0.33.0 turbo: ^1.10.7 typescript: ^5.2.2 peerDependencies: @@ -5828,6 +5837,13 @@ __metadata: languageName: node linkType: hard +"@tsd/typescript@npm:^5.9.2": + version: 5.9.3 + resolution: "@tsd/typescript@npm:5.9.3" + checksum: d1209e850cb36715b62305821f87877c11756cb0530d562f2d0c7f34feb34d6524c13d12f79f020c6bf69d8e3f5085deaef6657004937668c38f4986d82fa98f + languageName: node + linkType: hard + "@tybys/wasm-util@npm:^0.10.0": version: 0.10.2 resolution: "@tybys/wasm-util@npm:0.10.2" @@ -5911,20 +5927,30 @@ __metadata: languageName: node linkType: hard -"@types/estree@npm:1.0.8": - version: 1.0.8 - resolution: "@types/estree@npm:1.0.8" - checksum: bd93e2e415b6f182ec4da1074e1f36c480f1d26add3e696d54fb30c09bc470897e41361c8fd957bf0985024f8fbf1e6e2aff977d79352ef7eb93a5c6dcff6c11 +"@types/eslint@npm:^7.2.13": + version: 7.29.0 + resolution: "@types/eslint@npm:7.29.0" + dependencies: + "@types/estree": "*" + "@types/json-schema": "*" + checksum: df13991c554954353ce8f3bb03e19da6cc71916889443d68d178d4f858b561ba4cc4a4f291c6eb9eebb7f864b12b9b9313051b3a8dfea3e513dadf3188a77bdf languageName: node linkType: hard -"@types/estree@npm:^1.0.6": +"@types/estree@npm:*, @types/estree@npm:^1.0.6": version: 1.0.9 resolution: "@types/estree@npm:1.0.9" checksum: 752c0afee3ec82b8e24484bf6a27dfa093bbf3de4ef1c20ed0364fb6ad2c0c7971e7504ed9a7aaff103a47e2d945ce7a17f74951743dd944782a0735f53170de languageName: node linkType: hard +"@types/estree@npm:1.0.8": + version: 1.0.8 + resolution: "@types/estree@npm:1.0.8" + checksum: bd93e2e415b6f182ec4da1074e1f36c480f1d26add3e696d54fb30c09bc470897e41361c8fd957bf0985024f8fbf1e6e2aff977d79352ef7eb93a5c6dcff6c11 + languageName: node + linkType: hard + "@types/graceful-fs@npm:^4.1.3": version: 4.1.9 resolution: "@types/graceful-fs@npm:4.1.9" @@ -5976,7 +6002,7 @@ __metadata: languageName: node linkType: hard -"@types/json-schema@npm:^7.0.15, @types/json-schema@npm:^7.0.9": +"@types/json-schema@npm:*, @types/json-schema@npm:^7.0.15, @types/json-schema@npm:^7.0.9": version: 7.0.15 resolution: "@types/json-schema@npm:7.0.15" checksum: 97ed0cb44d4070aecea772b7b2e2ed971e10c81ec87dd4ecc160322ffa55ff330dace1793489540e3e318d90942064bb697cc0f8989391797792d919737b3b98 @@ -5990,7 +6016,7 @@ __metadata: languageName: node linkType: hard -"@types/minimist@npm:^1.2.2": +"@types/minimist@npm:^1.2.0, @types/minimist@npm:^1.2.2": version: 1.2.5 resolution: "@types/minimist@npm:1.2.5" checksum: 477047b606005058ab0263c4f58097136268007f320003c348794f74adedc3166ffc47c80ec3e94687787f2ab7f4e72c468223946e79892cf0fd9e25e9970a90 @@ -7707,6 +7733,17 @@ __metadata: languageName: node linkType: hard +"camelcase-keys@npm:^6.2.2": + version: 6.2.2 + resolution: "camelcase-keys@npm:6.2.2" + dependencies: + camelcase: ^5.3.1 + map-obj: ^4.0.0 + quick-lru: ^4.0.1 + checksum: 43c9af1adf840471e54c68ab3e5fe8a62719a6b7dbf4e2e86886b7b0ff96112c945736342b837bd2529ec9d1c7d1934e5653318478d98e0cf22c475c04658e2a + languageName: node + linkType: hard + "camelcase-keys@npm:^7.0.0": version: 7.0.2 resolution: "camelcase-keys@npm:7.0.2" @@ -9429,6 +9466,22 @@ __metadata: languageName: node linkType: hard +"eslint-formatter-pretty@npm:^4.1.0": + version: 4.1.0 + resolution: "eslint-formatter-pretty@npm:4.1.0" + dependencies: + "@types/eslint": ^7.2.13 + ansi-escapes: ^4.2.1 + chalk: ^4.1.0 + eslint-rule-docs: ^1.1.5 + log-symbols: ^4.0.0 + plur: ^4.0.0 + string-width: ^4.2.0 + supports-hyperlinks: ^2.0.0 + checksum: e8e0cd3843513fff32a70b036dd349fdab81d73b5e522f23685181c907a1faf2b2ebcae1688dc71d0fc026184011792f7e39b833d349df18fe2baea00d017901 + languageName: node + linkType: hard + "eslint-import-context@npm:^0.1.8": version: 0.1.9 resolution: "eslint-import-context@npm:0.1.9" @@ -9705,6 +9758,13 @@ __metadata: languageName: node linkType: hard +"eslint-rule-docs@npm:^1.1.5": + version: 1.1.235 + resolution: "eslint-rule-docs@npm:1.1.235" + checksum: b163596f9a05568e287b2c78f51a280092122a2e43c45fa2c200f0bd3f61877af186c641dab97620978bec96d9e2cfb621e51728044d9efe42ddc24f5a594b26 + languageName: node + linkType: hard + "eslint-scope@npm:5.1.1, eslint-scope@npm:^5.1.1": version: 5.1.1 resolution: "eslint-scope@npm:5.1.1" @@ -11612,6 +11672,13 @@ __metadata: languageName: node linkType: hard +"hosted-git-info@npm:^2.1.4": + version: 2.8.9 + resolution: "hosted-git-info@npm:2.8.9" + checksum: c955394bdab888a1e9bb10eb33029e0f7ce5a2ac7b3f158099dc8c486c99e73809dca609f5694b223920ca2174db33d32b12f9a2a47141dc59607c29da5a62dd + languageName: node + linkType: hard + "hosted-git-info@npm:^4.0.1": version: 4.1.0 resolution: "hosted-git-info@npm:4.1.0" @@ -11900,6 +11967,13 @@ __metadata: languageName: node linkType: hard +"irregular-plurals@npm:^3.2.0": + version: 3.5.0 + resolution: "irregular-plurals@npm:3.5.0" + checksum: 5b663091dc89155df7b2e9d053e8fb11941a0c4be95c4b6549ed3ea020489fdf4f75ea586c915b5b543704252679a5a6e8c6c3587da5ac3fc57b12da90a9aee7 + languageName: node + linkType: hard + "is-absolute@npm:^1.0.0": version: 1.0.0 resolution: "is-absolute@npm:1.0.0" @@ -12686,7 +12760,7 @@ __metadata: languageName: node linkType: hard -"jest-diff@npm:^29.7.0": +"jest-diff@npm:^29.0.3, jest-diff@npm:^29.7.0": version: 29.7.0 resolution: "jest-diff@npm:29.7.0" dependencies: @@ -13628,7 +13702,7 @@ __metadata: languageName: node linkType: hard -"log-symbols@npm:^4.1.0": +"log-symbols@npm:^4.0.0, log-symbols@npm:^4.1.0": version: 4.1.0 resolution: "log-symbols@npm:4.1.0" dependencies: @@ -13743,7 +13817,7 @@ __metadata: languageName: node linkType: hard -"map-obj@npm:^4.1.0": +"map-obj@npm:^4.0.0, map-obj@npm:^4.1.0": version: 4.3.0 resolution: "map-obj@npm:4.3.0" checksum: fbc554934d1a27a1910e842bc87b177b1a556609dd803747c85ece420692380827c6ae94a95cce4407c054fa0964be3bf8226f7f2cb2e9eeee432c7c1985684e @@ -13819,6 +13893,26 @@ __metadata: languageName: node linkType: hard +"meow@npm:^9.0.0": + version: 9.0.0 + resolution: "meow@npm:9.0.0" + dependencies: + "@types/minimist": ^1.2.0 + camelcase-keys: ^6.2.2 + decamelize: ^1.2.0 + decamelize-keys: ^1.1.0 + hard-rejection: ^2.1.0 + minimist-options: 4.1.0 + normalize-package-data: ^3.0.0 + read-pkg-up: ^7.0.1 + redent: ^3.0.0 + trim-newlines: ^3.0.0 + type-fest: ^0.18.0 + yargs-parser: ^20.2.3 + checksum: 99799c47247f4daeee178e3124f6ef6f84bde2ba3f37652865d5d8f8b8adcf9eedfc551dd043e2455cd8206545fd848e269c0c5ab6b594680a0ad4d3617c9639 + languageName: node + linkType: hard + "merge-options@npm:^3.0.4": version: 3.0.4 resolution: "merge-options@npm:3.0.4" @@ -15141,7 +15235,19 @@ __metadata: languageName: node linkType: hard -"normalize-package-data@npm:^3.0.2": +"normalize-package-data@npm:^2.5.0": + version: 2.5.0 + resolution: "normalize-package-data@npm:2.5.0" + dependencies: + hosted-git-info: ^2.1.4 + resolve: ^1.10.0 + semver: 2 || 3 || 4 || 5 + validate-npm-package-license: ^3.0.1 + checksum: 7999112efc35a6259bc22db460540cae06564aa65d0271e3bdfa86876d08b0e578b7b5b0028ee61b23f1cae9fc0e7847e4edc0948d3068a39a2a82853efc8499 + languageName: node + linkType: hard + +"normalize-package-data@npm:^3.0.0, normalize-package-data@npm:^3.0.2": version: 3.0.3 resolution: "normalize-package-data@npm:3.0.3" dependencies: @@ -15681,7 +15787,7 @@ __metadata: languageName: node linkType: hard -"parse-json@npm:^5.2.0": +"parse-json@npm:^5.0.0, parse-json@npm:^5.2.0": version: 5.2.0 resolution: "parse-json@npm:5.2.0" dependencies: @@ -15880,6 +15986,15 @@ __metadata: languageName: node linkType: hard +"plur@npm:^4.0.0": + version: 4.0.0 + resolution: "plur@npm:4.0.0" + dependencies: + irregular-plurals: ^3.2.0 + checksum: fea2e903efca67cc5c7a8952fca3db46ae8d9e9353373b406714977e601a5d3b628bcb043c3ad2126c6ff0e73d8020bf43af30a72dd087eff1ec240eb13b90e1 + languageName: node + linkType: hard + "pngjs@npm:^3.3.0": version: 3.4.0 resolution: "pngjs@npm:3.4.0" @@ -16173,6 +16288,13 @@ __metadata: languageName: node linkType: hard +"quick-lru@npm:^4.0.1": + version: 4.0.1 + resolution: "quick-lru@npm:4.0.1" + checksum: bea46e1abfaa07023e047d3cf1716a06172c4947886c053ede5c50321893711577cb6119360f810cc3ffcd70c4d7db4069c3cee876b358ceff8596e062bd1154 + languageName: node + linkType: hard + "quick-lru@npm:^5.1.1": version: 5.1.1 resolution: "quick-lru@npm:5.1.1" @@ -16869,6 +16991,17 @@ __metadata: languageName: node linkType: hard +"read-pkg-up@npm:^7.0.0, read-pkg-up@npm:^7.0.1": + version: 7.0.1 + resolution: "read-pkg-up@npm:7.0.1" + dependencies: + find-up: ^4.1.0 + read-pkg: ^5.2.0 + type-fest: ^0.8.1 + checksum: e4e93ce70e5905b490ca8f883eb9e48b5d3cebc6cd4527c25a0d8f3ae2903bd4121c5ab9c5a3e217ada0141098eeb661313c86fa008524b089b8ed0b7f165e44 + languageName: node + linkType: hard + "read-pkg-up@npm:^8.0.0": version: 8.0.0 resolution: "read-pkg-up@npm:8.0.0" @@ -16880,6 +17013,18 @@ __metadata: languageName: node linkType: hard +"read-pkg@npm:^5.2.0": + version: 5.2.0 + resolution: "read-pkg@npm:5.2.0" + dependencies: + "@types/normalize-package-data": ^2.4.0 + normalize-package-data: ^2.5.0 + parse-json: ^5.0.0 + type-fest: ^0.6.0 + checksum: eb696e60528b29aebe10e499ba93f44991908c57d70f2d26f369e46b8b9afc208ef11b4ba64f67630f31df8b6872129e0a8933c8c53b7b4daf0eace536901222 + languageName: node + linkType: hard + "read-pkg@npm:^6.0.0": version: 6.0.0 resolution: "read-pkg@npm:6.0.0" @@ -17165,7 +17310,7 @@ __metadata: languageName: node linkType: hard -"resolve@npm:^1.1.6, resolve@npm:^1.20.0, resolve@npm:^1.22.11, resolve@npm:^1.22.2": +"resolve@npm:^1.1.6, resolve@npm:^1.10.0, resolve@npm:^1.20.0, resolve@npm:^1.22.11, resolve@npm:^1.22.2": version: 1.22.12 resolution: "resolve@npm:1.22.12" dependencies: @@ -17204,7 +17349,7 @@ __metadata: languageName: node linkType: hard -"resolve@patch:resolve@^1.1.6#~builtin, resolve@patch:resolve@^1.20.0#~builtin, resolve@patch:resolve@^1.22.11#~builtin, resolve@patch:resolve@^1.22.2#~builtin": +"resolve@patch:resolve@^1.1.6#~builtin, resolve@patch:resolve@^1.10.0#~builtin, resolve@patch:resolve@^1.20.0#~builtin, resolve@patch:resolve@^1.22.11#~builtin, resolve@patch:resolve@^1.22.2#~builtin": version: 1.22.12 resolution: "resolve@patch:resolve@npm%3A1.22.12#~builtin::version=1.22.12&hash=c3c19d" dependencies: @@ -17496,6 +17641,15 @@ __metadata: languageName: node linkType: hard +"semver@npm:2 || 3 || 4 || 5": + version: 5.7.2 + resolution: "semver@npm:5.7.2" + bin: + semver: bin/semver + checksum: fb4ab5e0dd1c22ce0c937ea390b4a822147a9c53dbd2a9a0132f12fe382902beef4fbf12cf51bb955248d8d15874ce8cd89532569756384f994309825f10b686 + languageName: node + linkType: hard + "semver@npm:7.6.3, semver@npm:~7.6.3": version: 7.6.3 resolution: "semver@npm:7.6.3" @@ -18517,6 +18671,13 @@ __metadata: languageName: node linkType: hard +"trim-newlines@npm:^3.0.0": + version: 3.0.1 + resolution: "trim-newlines@npm:3.0.1" + checksum: b530f3fadf78e570cf3c761fb74fef655beff6b0f84b29209bac6c9622db75ad1417f4a7b5d54c96605dcd72734ad44526fef9f396807b90839449eb543c6206 + languageName: node + linkType: hard + "trim-newlines@npm:^4.0.2": version: 4.1.1 resolution: "trim-newlines@npm:4.1.1" @@ -18571,6 +18732,23 @@ __metadata: languageName: node linkType: hard +"tsd@npm:^0.33.0": + version: 0.33.0 + resolution: "tsd@npm:0.33.0" + dependencies: + "@tsd/typescript": ^5.9.2 + eslint-formatter-pretty: ^4.1.0 + globby: ^11.0.1 + jest-diff: ^29.0.3 + meow: ^9.0.0 + path-exists: ^4.0.0 + read-pkg-up: ^7.0.0 + bin: + tsd: dist/cli.js + checksum: 2916bcfd9d46bbeaab09e28ca714d4792c64fe12eda1a31e3d0786546fe93a1d2aeba0af2a68be4f9b211d3466ecf4f0187e4dbe45fe9f3eb29c4690c98e3379 + languageName: node + linkType: hard + "tslib@npm:^1.8.1": version: 1.14.1 resolution: "tslib@npm:1.14.1" @@ -18683,6 +18861,13 @@ __metadata: languageName: node linkType: hard +"type-fest@npm:^0.18.0": + version: 0.18.1 + resolution: "type-fest@npm:0.18.1" + checksum: e96dcee18abe50ec82dab6cbc4751b3a82046da54c52e3b2d035b3c519732c0b3dd7a2fa9df24efd1a38d953d8d4813c50985f215f1957ee5e4f26b0fe0da395 + languageName: node + linkType: hard + "type-fest@npm:^0.21.3": version: 0.21.3 resolution: "type-fest@npm:0.21.3" @@ -18690,6 +18875,13 @@ __metadata: languageName: node linkType: hard +"type-fest@npm:^0.6.0": + version: 0.6.0 + resolution: "type-fest@npm:0.6.0" + checksum: b2188e6e4b21557f6e92960ec496d28a51d68658018cba8b597bd3ef757721d1db309f120ae987abeeda874511d14b776157ff809f23c6d1ce8f83b9b2b7d60f + languageName: node + linkType: hard + "type-fest@npm:^0.7.1": version: 0.7.1 resolution: "type-fest@npm:0.7.1" @@ -18697,6 +18889,13 @@ __metadata: languageName: node linkType: hard +"type-fest@npm:^0.8.1": + version: 0.8.1 + resolution: "type-fest@npm:0.8.1" + checksum: d61c4b2eba24009033ae4500d7d818a94fd6d1b481a8111612ee141400d5f1db46f199c014766b9fa9b31a6a7374d96fc748c6d688a78a3ce5a33123839becb7 + languageName: node + linkType: hard + "type-fest@npm:^1.0.1, type-fest@npm:^1.2.1, type-fest@npm:^1.2.2": version: 1.4.0 resolution: "type-fest@npm:1.4.0" @@ -19640,7 +19839,7 @@ __metadata: languageName: node linkType: hard -"yargs-parser@npm:^20.2.9": +"yargs-parser@npm:^20.2.3, yargs-parser@npm:^20.2.9": version: 20.2.9 resolution: "yargs-parser@npm:20.2.9" checksum: 8bb69015f2b0ff9e17b2c8e6bfe224ab463dd00ca211eece72a4cd8a906224d2703fb8a326d36fdd0e68701e201b2a60ed7cf81ce0fd9b3799f9fe7745977ae3 From 9add5621d3403c5971ae1e64afbaf5f267039be5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Fri, 12 Jun 2026 22:35:40 +0200 Subject: [PATCH 02/24] chore: fix lint (prettier) and exclude test-d.ts from jest --- example/assets/rive/GradientBorder.riv | Bin 0 -> 3661 bytes example/assets/rive/GradientBorder.riv.d.ts | 6 +- example/assets/rive/artboard_db_test.riv.d.ts | 14 +-- example/assets/rive/blinko.riv.d.ts | 114 ++++++++++-------- example/assets/rive/bouncing_ball.riv.d.ts | 6 +- example/assets/rive/counter.riv.d.ts | 6 +- example/assets/rive/databinding.riv.d.ts | 26 ++-- .../assets/rive/databinding_images.riv.d.ts | 6 +- .../assets/rive/databinding_lists.riv.d.ts | 10 +- example/assets/rive/fallback_fonts.riv.d.ts | 2 +- example/assets/rive/font_fallback.riv.d.ts | 6 +- example/assets/rive/inputglow.riv | Bin 0 -> 3786 bytes example/assets/rive/inputglow.riv.d.ts | 6 +- .../ios_android_layouts_demo_v01.riv.d.ts | 2 +- example/assets/rive/layout_test.riv | Bin 0 -> 420 bytes example/assets/rive/layout_test.riv.d.ts | 6 +- example/assets/rive/layouts_demo.riv.d.ts | 2 +- example/assets/rive/many_viewmodels.riv.d.ts | 10 +- example/assets/rive/movecircle.riv.d.ts | 6 +- .../assets/rive/nodefaultbouncing.riv.d.ts | 6 +- example/assets/rive/on_entry_test.riv.d.ts | 8 +- example/assets/rive/out_of_band.riv.d.ts | 2 +- example/assets/rive/quick_start.riv.d.ts | 14 +-- example/assets/rive/rewards.riv.d.ts | 61 +++++----- .../assets/rive/style_fallback_fonts.riv.d.ts | 2 +- .../assets/rive/viewmodelproperty.riv.d.ts | 12 +- example/assets/rive/vm_value_change_test.riv | Bin 0 -> 877710 bytes .../assets/rive/vm_value_change_test.riv.d.ts | 8 +- package.json | 4 + scripts/__tests__/rive-extract-schema.test.ts | 14 ++- scripts/__tests__/rive-gen-types.test.ts | 3 +- src/core/RiveFile.ts | 12 +- src/core/RiveView.tsx | 9 +- src/core/TypedRiveFile.ts | 7 +- src/core/TypedViewModelInstance.ts | 50 ++++---- src/hooks/useRiveBoolean.ts | 5 +- src/hooks/useRiveColor.ts | 5 +- src/hooks/useRiveFile.ts | 6 +- src/hooks/useRiveNumber.ts | 5 +- src/hooks/useRiveString.ts | 5 +- src/hooks/useRiveTrigger.ts | 5 +- src/index.tsx | 12 +- 42 files changed, 275 insertions(+), 208 deletions(-) create mode 100644 example/assets/rive/GradientBorder.riv create mode 100644 example/assets/rive/inputglow.riv create mode 100644 example/assets/rive/layout_test.riv create mode 100644 example/assets/rive/vm_value_change_test.riv diff --git a/example/assets/rive/GradientBorder.riv b/example/assets/rive/GradientBorder.riv new file mode 100644 index 0000000000000000000000000000000000000000..aa883225cbb631a3287b5b4fedc5b8a08fd73033 GIT binary patch literal 3661 zcmZ`+eQZ=!7C(31y;D|fi$&VL25Ko5r6P13YAMiZ=S`hm3}!)TX^i^^!t919V4x`L z7iG7!Mls@dKt&RoNJxyXirN-aX6i1k_^}v4B47dKv!7@}jM-4nx%a#`uS%P|$^D&k z?(h80x#!)^+&RDgwhZ`R`^t|+pEw@)E-+v<%T2OHw#wb|P5HjuFF%!^$%FEc?2#wr zX?aGTmFMJnc|rEdKG`n^5!x&Tr=>U}#aSuNNpW6^ z3sUq-(I>@4DSkwJisNI+0!xpZsMo-`87-YJY+9(h`-vzE3Ida zwx_g;$1YcP+reZgRsYsk|L$7S5ghNTGpwX;eobBG3AE>`>7@X}&SZdlQ^f$i&J=*V z9T=~!nflZRFsv7Q=hP10fL*MH9CdR^XBI1%R5NH8cSLp0 z2cGY7vP%Am=Q2)B(m4z9G!CWgp2po?0y1GvOyD#1pPm%6yK{t>Q%Cu8Vyc;(Dp$=c z&3>deHTmlOPbQ1k)In?tt*{%{PkpWGCTfdbfN9I1B|%v`)ibGeRc%UuiyygmRW;!O z_TTf26Y=BEKU<*vINO0{NkwkbpDp^cRev6mfgWj{kk)9!-!H|06oXO>c`rh~3eLoV zs)1`&5T6M*2Jmwdeom~WL96LoP}3RxaL2zQS284S**d4@Z-JJ%(eU;iUPS)9+|KAH z-|vbz1t}Z^Ci-Z}(az|9?rn}ZZ{4~Pt*-rWZhIv9!^PQNpf-HBs-oJN_SX&7a9u_4 zuEwQ}E0)cJs(BFscK8}7D4z_4wSn8p;;nE0F@><0;j!K?yAVz>5Lcz_pw|$$=AdaR zl+f0OEz$B}gg0=k9Ukvru9MqpuV z9;UnnX&N0UjNM%;+~s<-hY^&K{XKzb7P(T0z9Llaq9Gr0>kY+qy)OIuONF%0P_l<9 zzdeAjL1BzZMsz8Jc2AwRAB|}>>8)6^>1YUbVMpDqSJlp-AS&#Y*?W?>G%D7NmECEo ziJxzx1YB70m$gwutf_fJ_Q(SYHRwyF#E5f&rgec)=psX8kbA6NajqgyjF%aYGJWu& z2D-q&P0GL|Wxz=paZ-)Eq}Usrd$%_XOhXuWz14Btf{{apb<>pSfW^4HbmQKLu0q65 zKKwN;y#c`(JDi7Sldor)W@gYmNe{G{0qTFFmQKXmi-85@Ht%anzTuu-d7J_7+c4`G zxp<%U+2MR&&Pd(`8i9}=+6nJ{LLlx3)PVB%t_?@Y!>j<`5MowMkydl?+0vB9`1q{z zl;1EiFpT%TG?BtQMoEYnHH96veL7iy(aHG@D}yWP{NW!5d^$BnT4&;L2RRKR1H;I` zleWc2qJ4I_z$b0nohM1VA*#D@nSdc;V5D&vv$Bf|*1oi~F_$aT($v{k2pC2NhLOXV zkzLHFeZK3?ok<&KvTqSy+l4V2PjAX;Qt`^y2O{Fzw%W8tE)KE7g;;T>zC`uQPZ#EO zrU@~dZ@j})`CPq4FO5n74ZLn@#46e6y-DcPU0}*57Or$DSN^nvmWGl?j48jE)5L0RfJ6tqEDbM^|mc8A<_{Dx;vT&Fu{C6|&Wl6sQESv?p88(w5H-iROssrG6 z?|_$q--yX0>Zm$eMt8Z%GO%+`x{gKrwh=H{9&I>9fa`d=Esr*Fw@TZtBE;R&g#H7_ zAF89RCPUNfe@SNm$fth;>+!Vj`TAxbKfppl-T`aG{F=@V7muhSID8`IHh@hOa literal 0 HcmV?d00001 diff --git a/example/assets/rive/GradientBorder.riv.d.ts b/example/assets/rive/GradientBorder.riv.d.ts index 3fdc9e8e..a964f379 100644 --- a/example/assets/rive/GradientBorder.riv.d.ts +++ b/example/assets/rive/GradientBorder.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - 'Layout': 'State'; + Layout: 'State'; }; viewModels: { - 'ViewModel': { - 'isFocused': 'boolean'; + ViewModel: { + isFocused: 'boolean'; }; }; }>; diff --git a/example/assets/rive/artboard_db_test.riv.d.ts b/example/assets/rive/artboard_db_test.riv.d.ts index 33d2c567..6b8b0eb6 100644 --- a/example/assets/rive/artboard_db_test.riv.d.ts +++ b/example/assets/rive/artboard_db_test.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Main' | 'ArtboardGreen' | 'ArtboardBlue' | 'ArtboardRed'; defaultArtboard: 'Main'; stateMachines: { - 'Main': 'State Machine 1'; - 'ArtboardGreen': 'State Machine 1'; - 'ArtboardBlue': 'State Machine 1'; - 'ArtboardRed': 'State Machine 1'; + Main: 'State Machine 1'; + ArtboardGreen: 'State Machine 1'; + ArtboardBlue: 'State Machine 1'; + ArtboardRed: 'State Machine 1'; }; viewModels: { - 'MainViewModel': { - 'artboard_1': 'artboard'; - 'artboard_2': 'artboard'; + MainViewModel: { + artboard_1: 'artboard'; + artboard_2: 'artboard'; }; }; }>; diff --git a/example/assets/rive/blinko.riv.d.ts b/example/assets/rive/blinko.riv.d.ts index 21865be3..dceb4852 100644 --- a/example/assets/rive/blinko.riv.d.ts +++ b/example/assets/rive/blinko.riv.d.ts @@ -3,40 +3,48 @@ // Source: blinko.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: 'Main' | 'StoreItem' | 'Token' | 'Indicator' | 'Puck' | 'StoreIcon' | 'Peg' | 'scoreBox'; + artboards: + | 'Main' + | 'StoreItem' + | 'Token' + | 'Indicator' + | 'Puck' + | 'StoreIcon' + | 'Peg' + | 'scoreBox'; defaultArtboard: 'Main'; stateMachines: { - 'Main': 'State Machine 1'; - 'StoreItem': 'State Machine 1'; - 'Token': 'State Machine 1'; - 'Indicator': 'State Machine 1'; - 'Puck': 'State Machine 1'; - 'StoreIcon': 'State Machine 1'; - 'Peg': 'State Machine 1'; - 'scoreBox': 'State Machine 1'; + Main: 'State Machine 1'; + StoreItem: 'State Machine 1'; + Token: 'State Machine 1'; + Indicator: 'State Machine 1'; + Puck: 'State Machine 1'; + StoreIcon: 'State Machine 1'; + Peg: 'State Machine 1'; + scoreBox: 'State Machine 1'; }; viewModels: { - 'IndicatorVM': { - 'purchased': 'boolean'; + IndicatorVM: { + purchased: 'boolean'; }; - 'StoreItemVM': { - 'tokenCount': 'number'; - 'height': 'number'; - 'itemHover': 'boolean'; - 'cost': 'number'; - 'description': 'string'; - 'id': 'string'; - 'itemType': 'string'; - 'maxPurchases': 'number'; - 'name': 'string'; - 'purchase': 'trigger'; - 'purchaseCount': 'number'; + StoreItemVM: { + tokenCount: 'number'; + height: 'number'; + itemHover: 'boolean'; + cost: 'number'; + description: 'string'; + id: 'string'; + itemType: 'string'; + maxPurchases: 'number'; + name: 'string'; + purchase: 'trigger'; + purchaseCount: 'number'; }; - 'storeIconVM': { - 'storeiconClick': 'trigger'; - 'iconHovered': 'boolean'; + storeIconVM: { + storeiconClick: 'trigger'; + iconHovered: 'boolean'; }; - 'storeVM': { + storeVM: { 'xbuttonClick': 'trigger'; 'xbuttonHover': 'boolean'; 'items': 'list'; @@ -52,37 +60,37 @@ declare const asset: RiveAsset<{ 'superMultiplierCost': 'number'; 'superMultiplierCount': 'number'; }; - 'TokenVM': { - 'spinToken': 'boolean'; + TokenVM: { + spinToken: 'boolean'; }; - 'pegVM': { - 'blink': 'trigger'; - 'multiplierValue': 'number'; - 'pegType': 'enumType'; - 'pegBounced': 'trigger'; + pegVM: { + blink: 'trigger'; + multiplierValue: 'number'; + pegType: 'enumType'; + pegBounced: 'trigger'; }; - 'gameLogicVM': { - 'turnTokens': 'number'; - 'turnScore': 'number'; - 'buttonLabel': 'string'; - 'message': 'string'; - 'startTurn': 'trigger'; - 'turnEnded': 'trigger'; - 'gameEnded': 'boolean'; - 'tokenCount': 'number'; - 'scoreTotal': 'number'; + gameLogicVM: { + turnTokens: 'number'; + turnScore: 'number'; + buttonLabel: 'string'; + message: 'string'; + startTurn: 'trigger'; + turnEnded: 'trigger'; + gameEnded: 'boolean'; + tokenCount: 'number'; + scoreTotal: 'number'; }; - 'scoreBox': { - 'Token': 'viewModel:TokenVM'; - 'slotType': 'enumType'; - 'landed': 'trigger'; - 'scoreValue': 'number'; + scoreBox: { + Token: 'viewModel:TokenVM'; + slotType: 'enumType'; + landed: 'trigger'; + scoreValue: 'number'; }; - 'PuckVM': { - 'puckBounce': 'trigger'; - 'puckRotation': 'number'; + PuckVM: { + puckBounce: 'trigger'; + puckRotation: 'number'; }; - 'main': { + main: { 'PuckVM': 'viewModel:PuckVM'; 'storeItemVM': 'viewModel:StoreItemVM'; 'storeIconVM': 'viewModel:storeIconVM'; diff --git a/example/assets/rive/bouncing_ball.riv.d.ts b/example/assets/rive/bouncing_ball.riv.d.ts index b6d2574d..10bc5f04 100644 --- a/example/assets/rive/bouncing_ball.riv.d.ts +++ b/example/assets/rive/bouncing_ball.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'vm': { - 'ypos': 'number'; + vm: { + ypos: 'number'; }; }; }>; diff --git a/example/assets/rive/counter.riv.d.ts b/example/assets/rive/counter.riv.d.ts index b1ba266a..244bbe14 100644 --- a/example/assets/rive/counter.riv.d.ts +++ b/example/assets/rive/counter.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel1': { - 'cnt': 'number'; + ViewModel1: { + cnt: 'number'; }; }; }>; diff --git a/example/assets/rive/databinding.riv.d.ts b/example/assets/rive/databinding.riv.d.ts index d7668f52..37ea853a 100644 --- a/example/assets/rive/databinding.riv.d.ts +++ b/example/assets/rive/databinding.riv.d.ts @@ -6,22 +6,22 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'Person': { - 'pet': 'viewModel:Pet'; - 'jump': 'trigger'; - 'likes_popcorn': 'boolean'; - 'favourite_pet': 'enumType'; - 'favourite_color': 'color'; - 'age': 'number'; - 'website': 'string'; - 'name': 'string'; + Person: { + pet: 'viewModel:Pet'; + jump: 'trigger'; + likes_popcorn: 'boolean'; + favourite_pet: 'enumType'; + favourite_color: 'color'; + age: 'number'; + website: 'string'; + name: 'string'; }; - 'Pet': { - 'type': 'enumType'; - 'name': 'string'; + Pet: { + type: 'enumType'; + name: 'string'; }; }; }>; diff --git a/example/assets/rive/databinding_images.riv.d.ts b/example/assets/rive/databinding_images.riv.d.ts index 6d788405..b9d93374 100644 --- a/example/assets/rive/databinding_images.riv.d.ts +++ b/example/assets/rive/databinding_images.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'MyViewModel': { - 'bound_image': 'image'; + MyViewModel: { + bound_image: 'image'; }; }; }>; diff --git a/example/assets/rive/databinding_lists.riv.d.ts b/example/assets/rive/databinding_lists.riv.d.ts index 75795551..00334476 100644 --- a/example/assets/rive/databinding_lists.riv.d.ts +++ b/example/assets/rive/databinding_lists.riv.d.ts @@ -6,14 +6,14 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'Person': { - 'name': 'string'; + Person: { + name: 'string'; }; - 'DevRel': { - 'team': 'list'; + DevRel: { + team: 'list'; }; }; }>; diff --git a/example/assets/rive/fallback_fonts.riv.d.ts b/example/assets/rive/fallback_fonts.riv.d.ts index ab210750..60e8aa1d 100644 --- a/example/assets/rive/fallback_fonts.riv.d.ts +++ b/example/assets/rive/fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/font_fallback.riv.d.ts b/example/assets/rive/font_fallback.riv.d.ts index 367dd2ab..02bdda87 100644 --- a/example/assets/rive/font_fallback.riv.d.ts +++ b/example/assets/rive/font_fallback.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel': { - 'text': 'string'; + ViewModel: { + text: 'string'; }; }; }>; diff --git a/example/assets/rive/inputglow.riv b/example/assets/rive/inputglow.riv new file mode 100644 index 0000000000000000000000000000000000000000..85e96d39d9be9bf71980c4b0d05f6a23fe072545 GIT binary patch literal 3786 zcmZ`+Yiv}<6+W|f?wUeu69~4iMU1gy18$nw>^gpc_i@+RmWZm5U}Ht;4+7f?B|rtH zp-odvYwRcwK_4W7G}IC+1tCRwG$gf6WOkht8uBPnAgDkLG(7zzl~7exxaZ8Ad-s}P zOZRHNGiSc@oik^~cOPET{9qRRqkG*4Vn`%?XMJD!MvQj3U3SP$c|g7{-<3z?NAhEN zT%M2v@|?UVFUiaDio7bX$w4_JhvkSIm1FX{{6=<~`^==-ZT6VG<{@*~gkk{b!sj7; zBKX|;*M^4u_)NtoAO2#zF2B>fHu2OCH>^oK35N-;-4x%jdh@2l8aQaYD?v_KvVK$R zs`aZAkTOg-AmO+aAhH2&^yfh2)y5A5WC5IrO#ukTMhr{}j^Hx?(pA6Mu(=hIxagu3 zm!!BX#T6;8N^wn!K`Dl$xGu#vNVXeYkRnACcOb=m@IS-!O$TV}!!W5>xA}v^hhshF zvo+IVy=r_&jlpLc*^#%mrE*SPnwCN&(fvoU9DqOBV3_7MAz-@cZxf#uq26~xoz;aSj6{N%qRveL^# z_DY-h!`k0edg_%utyDa7v##Irr>fG;Z+!k?-^w2UOh=t&C3Q<8P1)zro@d@)0WfaQ z1$aDN0x)Qo0z7KNO!Ln2=ih^IH8@n?I6e=n7={^UWm!dj?l@M($Uc+oh~+%wFSD^Y zv#>IznOAV6{9@Yr`Fnp%6{3GsnbtfqYFm3Q+?&pr0M6Q&$33>!G@AC9c1g1eyAZla zVpYYw9fRq)Z%#WJE!p|xRlAf%sBAVpAxSV7=gP?KR&bO`|v#n-?PKimyw~Rk>2QE zyWR@j&X8ERyFT($U&o?oU~iY}QLs3#H+uA6`$KkN8vBNc-d}mTH~P27+e7vn4{SrL zV?UYK9g2Q^z1DS9hOgGwgzW`C*&2p9HU39hSGBHPy%-u6hXh!GJE5?8E)+HT9t^}g z-~4_WVF|-CgP-*wEY%Q46+A(w7MIRIQ#q8;(w3dk>T!hg*w+fo^i1|Fvpth>bpWiu zEcBRx{-k1#J5~xeZg?V5HzpQM6d2S3i(-p0WHr*X+E5gGv{5+2EogrLK_%JW5r}GN zDvjuKLbVPW^B^bRU|i+vuy46hMC&vq&oJdbkKv&xiZRKADh1K*s&m()F{3846m!-U z4WcfrsIzox<9*~riM>*LFoi>{V&gQ~pP`!l$#x3BiIsfT7)8XI+PCIT+@N5Kx`WEJ zI0qK~gu+ z@N12$&_0CZOaW9|( z)W-L3Jxw#r3h*T%W>pj!HOGHfk#-q>9lT2MH6sJf_{2-I$<1YygqTrLSOLqUlLcs< z9AC3CxSh_ge{;;EQ&D7eCQkOyq-JEG85y|Jc6vzEoE0eaNZa%9dD5poti0 zY3#ZML(B2nE{aimx?N74 zidVkc5E0+A+oCaYv5OTb#*DMoC8`cTU6^xq5n>kKcqb|IMQVu}YLx&AxYbmMRq~vB zl5kE{fhnI|w$7nk_wOzmYD#V~ru=k48%;4~<+0_2m{KuVfszSIx#t(L?7cSnukZpL zh231?-|BfcO6CNxa2Du9c!3l-5fr#x9su7u18xL95v3FIXgFO-ce#!-vhQFfkL8E= z5YSP6)pCIV=ka1PpB8boDw0zPakUhocLNH>nrNwx(DvsaXCeR;(7%B#xZ96?@jVYe zz%oMa1}nt;ip~n$Ga(EA__?$jgMm}4N!y71I0_?{+*jilCv91k&aOOpM0GK z-Em)bKjq0I_tR%QdHnu`c0wFM5n6$Hm)o;1?ztioAw# zsID>TD=7hW&xtJj)s)y+T!kNX4Z8$D^kpIUiYr-XefTr64lWpQ%78xOBl%zaf#}1J oya5Bw8=d&^875ybnTH~pY?79Tpdm?o;ax~VOm5Wr$(F(Y0ght1hyVZp literal 0 HcmV?d00001 diff --git a/example/assets/rive/inputglow.riv.d.ts b/example/assets/rive/inputglow.riv.d.ts index 3b51f663..c1a84c21 100644 --- a/example/assets/rive/inputglow.riv.d.ts +++ b/example/assets/rive/inputglow.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - 'Layout': 'State'; + Layout: 'State'; }; viewModels: { - 'ViewModel': { - 'isFocused': 'boolean'; + ViewModel: { + isFocused: 'boolean'; }; }; }>; diff --git a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts index 80be047c..549ba94c 100644 --- a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts +++ b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + iOS_Android_Layouts_demo_v01: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/layout_test.riv b/example/assets/rive/layout_test.riv new file mode 100644 index 0000000000000000000000000000000000000000..24f2f8182bff2c0e7684499fe5f15bc175aa980e GIT binary patch literal 420 zcmaKny-EW?6ot=q&ag3!AcA&o6WC5HBv`0fL{Kn|O8PZfFcK4p3u3pLLa@{T zhe?D5tS%=8_*5g2;CXPvtp?i_uUf#kwo;Dc^l__97=h3|ig_Hf7PCotr?e<-N{7;= zd{83FH>F3xl^GpQ(Z-rcH5xCm)%+K*W2@~BthPI_+U}W_b1kn_Z&d#$gc`VZjde5y zeDyJ*;fxq6!zrz1%&Rk)PA9jDdw!`{_U&2BrN=e{FYxWGm*4q4nm-k5-8=NFroD&^ Mmf&8B!or0BKR`8QxBvhE literal 0 HcmV?d00001 diff --git a/example/assets/rive/layout_test.riv.d.ts b/example/assets/rive/layout_test.riv.d.ts index 008fd913..b513d8b8 100644 --- a/example/assets/rive/layout_test.riv.d.ts +++ b/example/assets/rive/layout_test.riv.d.ts @@ -6,12 +6,10 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel1': { - - }; + ViewModel1: {}; }; }>; export default asset; diff --git a/example/assets/rive/layouts_demo.riv.d.ts b/example/assets/rive/layouts_demo.riv.d.ts index a5587ce3..ac330ad0 100644 --- a/example/assets/rive/layouts_demo.riv.d.ts +++ b/example/assets/rive/layouts_demo.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + iOS_Android_Layouts_demo_v01: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/many_viewmodels.riv.d.ts b/example/assets/rive/many_viewmodels.riv.d.ts index 2a890294..4e717058 100644 --- a/example/assets/rive/many_viewmodels.riv.d.ts +++ b/example/assets/rive/many_viewmodels.riv.d.ts @@ -6,13 +6,13 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'First': { - 'imageValue': 'image'; - 'colorValue': 'color'; - 'textValue': 'string'; + First: { + imageValue: 'image'; + colorValue: 'color'; + textValue: 'string'; }; }; }>; diff --git a/example/assets/rive/movecircle.riv.d.ts b/example/assets/rive/movecircle.riv.d.ts index f63db94b..229ae35c 100644 --- a/example/assets/rive/movecircle.riv.d.ts +++ b/example/assets/rive/movecircle.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel': { - 'posY': 'number'; + ViewModel: { + posY: 'number'; }; }; }>; diff --git a/example/assets/rive/nodefaultbouncing.riv.d.ts b/example/assets/rive/nodefaultbouncing.riv.d.ts index 9a16de8e..cabe01ee 100644 --- a/example/assets/rive/nodefaultbouncing.riv.d.ts +++ b/example/assets/rive/nodefaultbouncing.riv.d.ts @@ -6,12 +6,10 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'VM1': { - - }; + VM1: {}; }; }>; export default asset; diff --git a/example/assets/rive/on_entry_test.riv.d.ts b/example/assets/rive/on_entry_test.riv.d.ts index 81e4ef07..56b087dc 100644 --- a/example/assets/rive/on_entry_test.riv.d.ts +++ b/example/assets/rive/on_entry_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'vm': { - 'input': 'number'; - 'inputOnEntry': 'number'; + vm: { + input: 'number'; + inputOnEntry: 'number'; }; }; }>; diff --git a/example/assets/rive/out_of_band.riv.d.ts b/example/assets/rive/out_of_band.riv.d.ts index 8b22e950..9546dc6a 100644 --- a/example/assets/rive/out_of_band.riv.d.ts +++ b/example/assets/rive/out_of_band.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/quick_start.riv.d.ts b/example/assets/rive/quick_start.riv.d.ts index b3abbe6b..4847c6a7 100644 --- a/example/assets/rive/quick_start.riv.d.ts +++ b/example/assets/rive/quick_start.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'health_bar_v01'; defaultArtboard: 'health_bar_v01'; stateMachines: { - 'health_bar_v01': 'State Machine 1'; + health_bar_v01: 'State Machine 1'; }; viewModels: { - 'health_bar_01': { - 'gameOver': 'trigger'; - 'hoverYes': 'boolean'; - 'hoverNo': 'boolean'; - 'healthColor': 'color'; - 'health': 'number'; + health_bar_01: { + gameOver: 'trigger'; + hoverYes: 'boolean'; + hoverNo: 'boolean'; + healthColor: 'color'; + health: 'number'; }; }; }>; diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts index 82b09211..ef205e47 100644 --- a/example/assets/rive/rewards.riv.d.ts +++ b/example/assets/rive/rewards.riv.d.ts @@ -3,7 +3,14 @@ // Source: rewards.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: 'Main' | 'Lives 2' | 'Item Value' | 'Chest' | 'Button' | 'Heart' | 'Item'; + artboards: + | 'Main' + | 'Lives 2' + | 'Item Value' + | 'Chest' + | 'Button' + | 'Heart' + | 'Item'; defaultArtboard: 'Main'; stateMachines: { 'Main': 'State Machine 1'; @@ -15,36 +22,36 @@ declare const asset: RiveAsset<{ 'Item': 'State Machine 1'; }; viewModels: { - 'Item_Icon_Value': { - 'Icon_React': 'trigger'; - 'Property_Of_Item': 'viewModel:Item'; - 'Item_Value': 'number'; + Item_Icon_Value: { + Icon_React: 'trigger'; + Property_Of_Item: 'viewModel:Item'; + Item_Value: 'number'; }; - 'Energy_Bar': { - 'Bar_Color': 'color'; - 'Lives': 'number'; - 'Energy_Bar': 'number'; + Energy_Bar: { + Bar_Color: 'color'; + Lives: 'number'; + Energy_Bar: 'number'; }; - 'Rewards': { - 'Price_Value': 'number'; - 'Color': 'color'; - 'Height': 'number'; - 'With': 'number'; - 'Item_Selection': 'viewModel:Item'; - 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; - 'Button': 'viewModel:Button'; - 'Coin': 'viewModel:Item_Icon_Value'; - 'Gem': 'viewModel:Item_Icon_Value'; - 'Energy_Bar': 'viewModel:Energy_Bar'; + Rewards: { + Price_Value: 'number'; + Color: 'color'; + Height: 'number'; + With: 'number'; + Item_Selection: 'viewModel:Item'; + Item_Value_Icon: 'viewModel:Item_Icon_Value'; + Button: 'viewModel:Button'; + Coin: 'viewModel:Item_Icon_Value'; + Gem: 'viewModel:Item_Icon_Value'; + Energy_Bar: 'viewModel:Energy_Bar'; }; - 'Button': { - 'State_1': 'string'; - 'Item_Text': 'string'; - 'Item': 'viewModel:Item'; - 'Pressed': 'trigger'; + Button: { + State_1: 'string'; + Item_Text: 'string'; + Item: 'viewModel:Item'; + Pressed: 'trigger'; }; - 'Item': { - 'Item_Selection': 'enumType'; + Item: { + Item_Selection: 'enumType'; }; }; }>; diff --git a/example/assets/rive/style_fallback_fonts.riv.d.ts b/example/assets/rive/style_fallback_fonts.riv.d.ts index 8e64cf29..ecd23149 100644 --- a/example/assets/rive/style_fallback_fonts.riv.d.ts +++ b/example/assets/rive/style_fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/viewmodelproperty.riv.d.ts b/example/assets/rive/viewmodelproperty.riv.d.ts index 744ad485..949846e8 100644 --- a/example/assets/rive/viewmodelproperty.riv.d.ts +++ b/example/assets/rive/viewmodelproperty.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'root': { - 'vm2': 'viewModel:vm'; - 'vm1': 'viewModel:vm'; + root: { + vm2: 'viewModel:vm'; + vm1: 'viewModel:vm'; }; - 'vm': { - 'name': 'string'; + vm: { + name: 'string'; }; }; }>; diff --git a/example/assets/rive/vm_value_change_test.riv b/example/assets/rive/vm_value_change_test.riv new file mode 100644 index 0000000000000000000000000000000000000000..5dc931d66b2b55532a0a0f580706437437beba2c GIT binary patch literal 877710 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

_-%YXC=1kQ{4+2K&}~92G=*L; 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

53ylYC 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 mc1%-#p5gREuZ9KF1I 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≺0PcqJuB!$gyrL>5V3U-3Qc8 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 literal 0 HcmV?d00001 diff --git a/example/assets/rive/vm_value_change_test.riv.d.ts b/example/assets/rive/vm_value_change_test.riv.d.ts index 674ed043..d092fc1f 100644 --- a/example/assets/rive/vm_value_change_test.riv.d.ts +++ b/example/assets/rive/vm_value_change_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'TextModel': { - 'trigger': 'trigger'; - 'textValue': 'string'; + TextModel: { + trigger: 'trigger'; + textValue: 'string'; }; }; }>; diff --git a/package.json b/package.json index 50789c36..c0fa7400 100644 --- a/package.json +++ b/package.json @@ -128,6 +128,10 @@ "/src/**/__tests__/**/*.{js,jsx,ts,tsx}", "/src/**/*.{spec,test}.{js,jsx,ts,tsx}" ], + "testPathIgnorePatterns": [ + "/node_modules/", + "\\.test-d\\.ts$" + ], "modulePathIgnorePatterns": [ "/example/node_modules", "/lib/" diff --git a/scripts/__tests__/rive-extract-schema.test.ts b/scripts/__tests__/rive-extract-schema.test.ts index d02cff50..fb6fbe1b 100644 --- a/scripts/__tests__/rive-extract-schema.test.ts +++ b/scripts/__tests__/rive-extract-schema.test.ts @@ -28,21 +28,25 @@ describe('rive-extract-schema', () => { }); test('extracts state machines per artboard', () => { - expect((schema.stateMachines as Record)['Main']).toContain('State Machine 1'); + expect((schema.stateMachines as Record).Main).toContain( + 'State Machine 1' + ); }); test('extracts viewModels', () => { - expect((schema.viewModels as Record)['Rewards']).toBeDefined(); + expect( + (schema.viewModels as Record).Rewards + ).toBeDefined(); }); test('resolves nested viewModel references', () => { const vms = schema.viewModels as Record>; - expect(vms['Rewards']!['Coin']).toBe('viewModel:Item_Icon_Value'); + expect(vms.Rewards!.Coin).toBe('viewModel:Item_Icon_Value'); }); test('extracts primitive property types', () => { const vms = schema.viewModels as Record>; - expect(vms['Item_Icon_Value']!['Item_Value']).toBe('number'); - expect(vms['Energy_Bar']!['Bar_Color']).toBe('color'); + expect(vms.Item_Icon_Value!.Item_Value).toBe('number'); + expect(vms.Energy_Bar!.Bar_Color).toBe('color'); }); }); diff --git a/scripts/__tests__/rive-gen-types.test.ts b/scripts/__tests__/rive-gen-types.test.ts index 9855973d..128b3e8d 100644 --- a/scripts/__tests__/rive-gen-types.test.ts +++ b/scripts/__tests__/rive-gen-types.test.ts @@ -14,7 +14,8 @@ describe('rive-gen-types', () => { timeout: 30_000, cwd: resolve(__dirname, '../..'), }); - if (result.status !== 0) throw new Error(result.stderr ?? 'generator failed'); + if (result.status !== 0) + throw new Error(result.stderr ?? 'generator failed'); }); test('generates .riv.d.ts next to source file', () => { diff --git a/src/core/RiveFile.ts b/src/core/RiveFile.ts index cfc44c54..d9229587 100644 --- a/src/core/RiveFile.ts +++ b/src/core/RiveFile.ts @@ -109,11 +109,19 @@ export namespace RiveFileFactory { // handle iOS bundled asset if (assetURI.match(/file:\/\//)) { - return RiveFileFactory.fromFileURL(assetURI, referencedAssets, loadCdn); + return RiveFileFactory.fromFileURL( + assetURI, + referencedAssets, + loadCdn + ); } // handle Android bundled asset or resource name uri - return RiveFileFactory.fromResource(assetURI, referencedAssets, loadCdn); + return RiveFileFactory.fromResource( + assetURI, + referencedAssets, + loadCdn + ); } catch (error: unknown) { const errorMessage = error instanceof Error ? error.message : String(error); diff --git a/src/core/RiveView.tsx b/src/core/RiveView.tsx index 7b2b7adf..14df1211 100644 --- a/src/core/RiveView.tsx +++ b/src/core/RiveView.tsx @@ -9,8 +9,11 @@ type NitroRiveViewProps = ComponentProps; export interface RiveViewProps< T extends RiveFileSchema = RiveFileSchema, - A extends T['artboards'] = T['defaultArtboard'] -> extends Omit { + A extends T['artboards'] = T['defaultArtboard'], +> extends Omit< + NitroRiveViewProps, + 'onError' | 'file' | 'artboardName' | 'stateMachineName' +> { onError?: (error: RiveError) => void; file: TypedRiveFile; /** Name of the artboard to display. When using a generated schema, only valid artboard names are accepted. */ @@ -27,7 +30,7 @@ const defaultOnError = (error: RiveError) => export function RiveView< T extends RiveFileSchema = RiveFileSchema, - A extends T['artboards'] = T['defaultArtboard'] + A extends T['artboards'] = T['defaultArtboard'], >(props: RiveViewProps) { const { onError, hybridRef: userHybridRef, ...rest } = props; const wrappedOnError = onError ?? defaultOnError; diff --git a/src/core/TypedRiveFile.ts b/src/core/TypedRiveFile.ts index 6aefc5b2..22ba97f9 100644 --- a/src/core/TypedRiveFile.ts +++ b/src/core/TypedRiveFile.ts @@ -38,6 +38,7 @@ export type RiveAsset = number & { * Obtain one via `RiveFileFactory.fromURL(...)` or * `RiveFileFactory.fromSource(typedAsset)`. */ -export type TypedRiveFile = RiveFile & { - readonly __schema?: T; -}; +export type TypedRiveFile = + RiveFile & { + readonly __schema?: T; + }; diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index 365904fb..fa60ccc9 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -16,17 +16,21 @@ import type { RiveFileSchema } from './TypedRiveFile'; * Elements can be any ViewModel defined in the file — the exact type is unknown * until runtime, so the element type is a union of all file ViewModels. */ -export interface TypedViewModelListProperty - extends Omit { +export interface TypedViewModelListProperty< + T extends RiveFileSchema, +> extends Omit { getInstanceAtAsync( index: number ): Promise< - TypedViewModelInstance> | undefined + | TypedViewModelInstance> + | undefined >; /** @deprecated Use getInstanceAtAsync instead */ getInstanceAt( index: number - ): TypedViewModelInstance> | undefined; + ): + | TypedViewModelInstance> + | undefined; } /** Property names whose type literal matches the given Kind */ @@ -61,7 +65,9 @@ type NestedPathsOfKind< VMName extends keyof T['viewModels'] & string, Kind extends string, > = { - [P in VMRefPropNames]: `${P}/${VMPropsOfKind], Kind>}`; + [P in VMRefPropNames< + T['viewModels'][VMName] + >]: `${P}/${VMPropsOfKind], Kind>}`; }[VMRefPropNames]; /** @@ -88,18 +94,18 @@ export interface TypedViewModelInstance< T extends RiveFileSchema, VMName extends keyof T['viewModels'] & string, > extends Omit< - ViewModelInstance, - | 'numberProperty' - | 'stringProperty' - | 'booleanProperty' - | 'colorProperty' - | 'triggerProperty' - | 'enumProperty' - | 'imageProperty' - | 'listProperty' - | 'viewModel' - | 'viewModelAsync' - > { + ViewModelInstance, + | 'numberProperty' + | 'stringProperty' + | 'booleanProperty' + | 'colorProperty' + | 'triggerProperty' + | 'enumProperty' + | 'imageProperty' + | 'listProperty' + | 'viewModel' + | 'viewModelAsync' +> { numberProperty( path: VMPropsOfKind ): ViewModelNumberProperty | undefined; @@ -135,10 +141,12 @@ export interface TypedViewModelInstance< /** Access a nested ViewModel instance; return type is typed to the referenced ViewModel. */ viewModel

    >( path: P - ): TypedViewModelInstance< - T, - VMRefName & keyof T['viewModels'] & string - > | undefined; + ): + | TypedViewModelInstance< + T, + VMRefName & keyof T['viewModels'] & string + > + | undefined; viewModelAsync

    >( path: P diff --git a/src/hooks/useRiveBoolean.ts b/src/hooks/useRiveBoolean.ts index f551b8de..6406c266 100644 --- a/src/hooks/useRiveBoolean.ts +++ b/src/hooks/useRiveBoolean.ts @@ -4,7 +4,10 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; -import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { + PathsOfKind, + TypedViewModelInstance, +} from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; const getBooleanProperty = (vmi: ViewModelInstance, p: string) => diff --git a/src/hooks/useRiveColor.ts b/src/hooks/useRiveColor.ts index 9e9ccf34..247a0d74 100644 --- a/src/hooks/useRiveColor.ts +++ b/src/hooks/useRiveColor.ts @@ -5,7 +5,10 @@ import type { } from '../specs/ViewModel.nitro'; import { useRiveProperty } from './useRiveProperty'; import { RiveColor } from '../core/RiveColor'; -import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { + PathsOfKind, + TypedViewModelInstance, +} from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; const getColorProperty = (vmi: ViewModelInstance, p: string) => diff --git a/src/hooks/useRiveFile.ts b/src/hooks/useRiveFile.ts index 5a030fc2..ea7cc651 100644 --- a/src/hooks/useRiveFile.ts +++ b/src/hooks/useRiveFile.ts @@ -12,7 +12,11 @@ import type { ReferencedAssets, ResolvedReferencedAssets, } from '../core/ReferencedAssets'; -import type { RiveAsset, RiveFileSchema, TypedRiveFile } from '../core/TypedRiveFile'; +import type { + RiveAsset, + RiveFileSchema, + TypedRiveFile, +} from '../core/TypedRiveFile'; export type { ReferencedAssets, ResolvedReferencedAssets }; export type RiveFileInput = number | { uri: string } | string | ArrayBuffer; diff --git a/src/hooks/useRiveNumber.ts b/src/hooks/useRiveNumber.ts index aacd55a4..ff8e904c 100644 --- a/src/hooks/useRiveNumber.ts +++ b/src/hooks/useRiveNumber.ts @@ -4,7 +4,10 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; -import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { + PathsOfKind, + TypedViewModelInstance, +} from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; const getNumberProperty = (vmi: ViewModelInstance, p: string) => diff --git a/src/hooks/useRiveString.ts b/src/hooks/useRiveString.ts index aab4980d..fe1b0fce 100644 --- a/src/hooks/useRiveString.ts +++ b/src/hooks/useRiveString.ts @@ -4,7 +4,10 @@ import { } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; import { useRiveProperty } from './useRiveProperty'; -import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { + PathsOfKind, + TypedViewModelInstance, +} from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; const getStringProperty = (vmi: ViewModelInstance, p: string) => diff --git a/src/hooks/useRiveTrigger.ts b/src/hooks/useRiveTrigger.ts index 7ab354eb..a600b40d 100644 --- a/src/hooks/useRiveTrigger.ts +++ b/src/hooks/useRiveTrigger.ts @@ -8,7 +8,10 @@ import type { UseViewModelInstanceTriggerParameters, } from '../types'; import { useDisposableMemo } from './useDisposableMemo'; -import type { PathsOfKind, TypedViewModelInstance } from '../core/TypedViewModelInstance'; +import type { + PathsOfKind, + TypedViewModelInstance, +} from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; /** diff --git a/src/index.tsx b/src/index.tsx index 7f5183ef..d8fe24d4 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -20,8 +20,16 @@ export { RiveView, type RiveViewProps } from './core/RiveView'; export type { RiveViewMethods }; export type RiveViewRef = HybridView; export type { RiveFile } from './specs/RiveFile.nitro'; -export type { RiveAsset, RiveFileSchema, TypedRiveFile } from './core/TypedRiveFile'; -export type { TypedViewModelInstance, TypedViewModelListProperty, PathsOfKind } from './core/TypedViewModelInstance'; +export type { + RiveAsset, + RiveFileSchema, + TypedRiveFile, +} from './core/TypedRiveFile'; +export type { + TypedViewModelInstance, + TypedViewModelListProperty, + PathsOfKind, +} from './core/TypedViewModelInstance'; export type { ViewModel, ViewModelInstance, From c1ff0bee6f670ad46df753fe26222f8e9b8953f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 07:51:52 +0200 Subject: [PATCH 03/24] chore: prettier format scripts --- scripts/rive-extract-schema.ts | 21 ++++++++++++++++----- scripts/rive-gen-types.ts | 18 +++++++++++++++--- 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index 16311ffe..558f13b9 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -17,13 +17,17 @@ const input: string | undefined = process.argv[2]; // @rive-app/canvas checks for browser globals during WASM initialisation. // We only call file-inspection APIs (no rendering), so minimal shims are enough. -(globalThis as any).document = { createElement: () => ({ getContext: () => null }) }; +(globalThis as any).document = { + createElement: () => ({ getContext: () => null }), +}; (globalThis as any).Image = class {}; // The WASM runtime prints warnings (e.g. "No WebGL support") via console. // Redirect them to stderr so our JSON output stays clean. -console.log = (...args: unknown[]) => process.stderr.write(args.join(' ') + '\n'); -console.warn = (...args: unknown[]) => process.stderr.write(args.join(' ') + '\n'); +console.log = (...args: unknown[]) => + process.stderr.write(args.join(' ') + '\n'); +console.warn = (...args: unknown[]) => + process.stderr.write(args.join(' ') + '\n'); if (!input) { process.stderr.write('Usage: bun rive-extract-schema.ts \n'); @@ -73,7 +77,10 @@ async function main() { const vmCount = (riveFile as any).viewModelCount() as number; for (let i = 0; i < vmCount; i++) { const vm = (riveFile as any).viewModelByIndex(i); - const properties = vm.getProperties() as Array<{ name: string; type: string }>; + const properties = vm.getProperties() as Array<{ + name: string; + type: string; + }>; // Create a blank instance to resolve viewModel property references const inst = vm.instance?.() as any; const props: Record = {}; @@ -95,7 +102,11 @@ async function main() { const defaultArtboard = artboards[0] ?? ''; process.stdout.write( - JSON.stringify({ artboards, defaultArtboard, stateMachines, viewModels }, null, 2) + '\n' + JSON.stringify( + { artboards, defaultArtboard, stateMachines, viewModels }, + null, + 2 + ) + '\n' ); } diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index ba30bb12..2a1fa6d9 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -31,7 +31,10 @@ interface Schema { function extractSchema(input: string): Schema { for (let attempt = 0; attempt < 2; attempt++) { try { - const json = execSync(`bun "${extractorPath}" "${input}"`, { encoding: 'utf8', timeout: 30_000 }); + const json = execSync(`bun "${extractorPath}" "${input}"`, { + encoding: 'utf8', + timeout: 30_000, + }); return JSON.parse(json) as Schema; } catch (err) { if (attempt === 1) throw err; @@ -86,7 +89,11 @@ export default asset; `; } -function standaloneContent(input: string, typeName: string, schema: Schema): string { +function standaloneContent( + input: string, + typeName: string, + schema: Schema +): string { return `\ // Generated by rive-gen-types — do not edit manually. // Source: ${input} @@ -98,7 +105,12 @@ ${schemaBody(schema)} `; } -function generate(input: string, outPath: string, mode: 'dts' | 'standalone', typeName?: string) { +function generate( + input: string, + outPath: string, + mode: 'dts' | 'standalone', + typeName?: string +) { let schema: Schema; try { schema = extractSchema(input); From 98ca7786df3ff4540437567247cb5ced2bdcb7c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 08:15:27 +0200 Subject: [PATCH 04/24] feat: extract enum values into schema, type enumProperty() and useRiveEnum --- example/assets/rive/blinko.riv.d.ts | 4 +- example/assets/rive/databinding.riv.d.ts | 4 +- example/assets/rive/rewards.riv.d.ts | 61 ++++++++----------- scripts/__tests__/rive-extract-schema.test.ts | 10 +++ scripts/rive-extract-schema.ts | 9 +++ src/__tests__/typed-rive.test-d.ts | 25 +++++++- src/core/TypedViewModelInstance.ts | 48 +++++++++++++-- src/hooks/useRiveEnum.ts | 27 +++++--- src/index.tsx | 2 + 9 files changed, 138 insertions(+), 52 deletions(-) diff --git a/example/assets/rive/blinko.riv.d.ts b/example/assets/rive/blinko.riv.d.ts index dceb4852..7070d1d2 100644 --- a/example/assets/rive/blinko.riv.d.ts +++ b/example/assets/rive/blinko.riv.d.ts @@ -66,7 +66,7 @@ declare const asset: RiveAsset<{ pegVM: { blink: 'trigger'; multiplierValue: 'number'; - pegType: 'enumType'; + pegType: 'enum:normal|multiplier'; pegBounced: 'trigger'; }; gameLogicVM: { @@ -82,7 +82,7 @@ declare const asset: RiveAsset<{ }; scoreBox: { Token: 'viewModel:TokenVM'; - slotType: 'enumType'; + slotType: 'enum:addToken|normal'; landed: 'trigger'; scoreValue: 'number'; }; diff --git a/example/assets/rive/databinding.riv.d.ts b/example/assets/rive/databinding.riv.d.ts index 37ea853a..f0b630e5 100644 --- a/example/assets/rive/databinding.riv.d.ts +++ b/example/assets/rive/databinding.riv.d.ts @@ -13,14 +13,14 @@ declare const asset: RiveAsset<{ pet: 'viewModel:Pet'; jump: 'trigger'; likes_popcorn: 'boolean'; - favourite_pet: 'enumType'; + favourite_pet: 'enum:chipmunk|rat|frog|owl|cat|dog'; favourite_color: 'color'; age: 'number'; website: 'string'; name: 'string'; }; Pet: { - type: 'enumType'; + type: 'enum:chipmunk|rat|frog|owl|cat|dog'; name: 'string'; }; }; diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts index ef205e47..e34022fc 100644 --- a/example/assets/rive/rewards.riv.d.ts +++ b/example/assets/rive/rewards.riv.d.ts @@ -3,14 +3,7 @@ // Source: rewards.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: - | 'Main' - | 'Lives 2' - | 'Item Value' - | 'Chest' - | 'Button' - | 'Heart' - | 'Item'; + artboards: 'Main' | 'Lives 2' | 'Item Value' | 'Chest' | 'Button' | 'Heart' | 'Item'; defaultArtboard: 'Main'; stateMachines: { 'Main': 'State Machine 1'; @@ -22,36 +15,36 @@ declare const asset: RiveAsset<{ 'Item': 'State Machine 1'; }; viewModels: { - Item_Icon_Value: { - Icon_React: 'trigger'; - Property_Of_Item: 'viewModel:Item'; - Item_Value: 'number'; + 'Item_Icon_Value': { + 'Icon_React': 'trigger'; + 'Property_Of_Item': 'viewModel:Item'; + 'Item_Value': 'number'; }; - Energy_Bar: { - Bar_Color: 'color'; - Lives: 'number'; - Energy_Bar: 'number'; + 'Energy_Bar': { + 'Bar_Color': 'color'; + 'Lives': 'number'; + 'Energy_Bar': 'number'; }; - Rewards: { - Price_Value: 'number'; - Color: 'color'; - Height: 'number'; - With: 'number'; - Item_Selection: 'viewModel:Item'; - Item_Value_Icon: 'viewModel:Item_Icon_Value'; - Button: 'viewModel:Button'; - Coin: 'viewModel:Item_Icon_Value'; - Gem: 'viewModel:Item_Icon_Value'; - Energy_Bar: 'viewModel:Energy_Bar'; + 'Rewards': { + 'Price_Value': 'number'; + 'Color': 'color'; + 'Height': 'number'; + 'With': 'number'; + 'Item_Selection': 'viewModel:Item'; + 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; + 'Button': 'viewModel:Button'; + 'Coin': 'viewModel:Item_Icon_Value'; + 'Gem': 'viewModel:Item_Icon_Value'; + 'Energy_Bar': 'viewModel:Energy_Bar'; }; - Button: { - State_1: 'string'; - Item_Text: 'string'; - Item: 'viewModel:Item'; - Pressed: 'trigger'; + 'Button': { + 'State_1': 'string'; + 'Item_Text': 'string'; + 'Item': 'viewModel:Item'; + 'Pressed': 'trigger'; }; - Item: { - Item_Selection: 'enumType'; + 'Item': { + 'Item_Selection': 'enum:Coin|Gem'; }; }; }>; diff --git a/scripts/__tests__/rive-extract-schema.test.ts b/scripts/__tests__/rive-extract-schema.test.ts index fb6fbe1b..0e5fe00f 100644 --- a/scripts/__tests__/rive-extract-schema.test.ts +++ b/scripts/__tests__/rive-extract-schema.test.ts @@ -49,4 +49,14 @@ describe('rive-extract-schema', () => { expect(vms.Item_Icon_Value!.Item_Value).toBe('number'); expect(vms.Energy_Bar!.Bar_Color).toBe('color'); }); + + test('extracts enum values as pipe-separated string', () => { + const databinding = extract( + resolve(__dirname, '../../example/assets/rive/databinding.riv') + ); + const vms = databinding.viewModels as Record>; + expect(vms.Person!.favourite_pet).toMatch(/^enum:/); + expect(vms.Person!.favourite_pet).toContain('chipmunk'); + expect(vms.Person!.favourite_pet).toContain('dog'); + }); }); diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index 558f13b9..34a31597 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -93,6 +93,15 @@ async function main() { } catch { props[p.name] = 'viewModel'; } + } else if (p.type === 'enumType' && inst) { + try { + const ep = inst.enum?.(p.name); + const values: string[] = ep?.values ?? []; + props[p.name] = + values.length > 0 ? `enum:${values.join('|')}` : 'enum'; + } catch { + props[p.name] = 'enum'; + } } else { props[p.name] = p.type; } diff --git a/src/__tests__/typed-rive.test-d.ts b/src/__tests__/typed-rive.test-d.ts index 0dc3adda..47b661b4 100644 --- a/src/__tests__/typed-rive.test-d.ts +++ b/src/__tests__/typed-rive.test-d.ts @@ -1,12 +1,15 @@ import { expectType, expectError, expectAssignable } from 'tsd'; import type { TypedRiveFile, RiveAsset } from '../../src/core/TypedRiveFile'; -import type { TypedViewModelInstance } from '../../src/core/TypedViewModelInstance'; +import type { + TypedViewModelInstance, + TypedViewModelListProperty, + TypedViewModelEnumProperty, +} from '../../src/core/TypedViewModelInstance'; import type { ViewModelNumberProperty, ViewModelTriggerProperty, ViewModelBooleanProperty, } from '../../src/specs/ViewModel.nitro'; -import type { TypedViewModelListProperty } from '../../src/core/TypedViewModelInstance'; import type { RiveViewProps } from '../../src/core/RiveView'; import gradientBorderRiv from '../../example/assets/rive/GradientBorder.riv'; import blinkoRiv from '../../example/assets/rive/blinko.riv'; @@ -188,6 +191,24 @@ expectError( storeVM.viewModel('property of pegVM')?.stringProperty('doesNotExist') ); +// --- Enum property --- + +// pegVM.pegType is 'enum:normal|multiplier' — returns typed enum property +expectAssignable< + TypedViewModelEnumProperty<'normal' | 'multiplier'> | undefined +>(storeVM.viewModel('property of pegVM')?.enumProperty('pegType')); + +// The enum value type is exactly 'normal' | 'multiplier' +expectType | undefined>( + storeVM.viewModel('property of pegVM')?.enumProperty('pegType') +); + +// Non-enum property rejected for enumProperty() +expectError(storeVM.enumProperty('xbuttonClick')); + +// Nonexistent property rejected +expectError(storeVM.enumProperty('doesNotExist')); + // --- List property --- // storeVM.items is a 'list' — returns a typed list property diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index fa60ccc9..32026a93 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -33,12 +33,48 @@ export interface TypedViewModelListProperty< | undefined; } -/** Property names whose type literal matches the given Kind */ +/** Split a pipe-separated string literal into a union: 'a|b|c' → 'a' | 'b' | 'c' */ +type UnionFromPipe = S extends `${infer A}|${infer B}` + ? A | UnionFromPipe + : S; + +/** Extract the enum value union from a schema type string like 'enum:cat|dog|frog' */ +export type EnumValuesOf = S extends `enum:${infer V}` + ? UnionFromPipe + : never; + +/** + * A typed enum property whose value and setter are constrained to the specific enum values + * extracted from the .riv file schema. + */ +export interface TypedViewModelEnumProperty< + Values extends string = string, +> extends Omit< + ViewModelEnumProperty, + 'value' | 'getValueAsync' | 'set' | 'addListener' +> { + /** @deprecated Use getValueAsync (read) or set(value) (write) instead */ + value: Values; + getValueAsync(): Promise; + set(value: Values): void; + addListener(onChanged: (value: Values) => void): () => void; +} + +/** + * Property names whose type matches the given Kind. + * Use kind `'enum'` to match any enum property (stored as `'enum:val1|val2'` in the schema). + */ export type VMPropsOfKind< VM extends Record, Kind extends string, > = { - [K in keyof VM]: VM[K] extends Kind ? K : never; + [K in keyof VM]: Kind extends 'enum' + ? VM[K] extends `enum:${string}` + ? K + : never + : VM[K] extends Kind + ? K + : never; }[keyof VM] & string; @@ -126,9 +162,11 @@ export interface TypedViewModelInstance< path: VMPropsOfKind ): ViewModelTriggerProperty | undefined; - enumProperty( - path: VMPropsOfKind - ): ViewModelEnumProperty | undefined; + enumProperty

    >( + path: P + ): + | TypedViewModelEnumProperty> + | undefined; imageProperty( path: VMPropsOfKind diff --git a/src/hooks/useRiveEnum.ts b/src/hooks/useRiveEnum.ts index ee5d67ba..710bfd9d 100644 --- a/src/hooks/useRiveEnum.ts +++ b/src/hooks/useRiveEnum.ts @@ -3,18 +3,31 @@ import { type ViewModelInstance, } from '../specs/ViewModel.nitro'; import type { UseRivePropertyResult } from '../types'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; +import { + type EnumValuesOf, + type TypedViewModelInstance, + type VMPropsOfKind, +} from '../core/TypedViewModelInstance'; import { useRiveProperty } from './useRiveProperty'; const getEnumProperty = (vmi: ViewModelInstance, p: string) => vmi.enumProperty(p); -/** - * Hook for interacting with enum ViewModel instance properties. - * - * @param path - The path to the enum property - * @param viewModelInstance - The ViewModelInstance containing the enum property to operate on - * @returns An object with the enum value, a setter function, and an error if the property is not found - */ +export function useRiveEnum< + T extends RiveFileSchema, + N extends Extract, + P extends VMPropsOfKind, +>( + path: P, + viewModelInstance?: TypedViewModelInstance | null +): UseRivePropertyResult>; + +export function useRiveEnum( + path: string, + viewModelInstance?: ViewModelInstance | null +): UseRivePropertyResult; + export function useRiveEnum( path: string, viewModelInstance?: ViewModelInstance | null diff --git a/src/index.tsx b/src/index.tsx index d8fe24d4..7d0ba36e 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -28,7 +28,9 @@ export type { export type { TypedViewModelInstance, TypedViewModelListProperty, + TypedViewModelEnumProperty, PathsOfKind, + EnumValuesOf, } from './core/TypedViewModelInstance'; export type { ViewModel, From 98cd17a59800bc8a739803bf00aefa74b2223f10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 09:38:55 +0200 Subject: [PATCH 05/24] feat: enforce typed property paths via phantom brand on TypedViewModelInstance Adds __vmBrand to TypedViewModelInstance so TypeScript rejects passing a typed instance to untyped hook overloads, ensuring wrong property paths are caught at compile time. Also adds allowArbitraryExtensions to tsconfig for .riv imports. --- example/assets/rive/rewards.riv.d.ts | 61 +++++++++++-------- .../src/exercisers/RiveDataBindingExample.tsx | 29 ++++++--- scripts/__tests__/rive-extract-schema.test.ts | 5 +- src/core/TypedViewModelInstance.ts | 3 + src/hooks/useRiveBoolean.ts | 2 +- src/hooks/useRiveColor.ts | 2 +- src/hooks/useRiveEnum.ts | 2 +- src/hooks/useRiveNumber.ts | 2 +- src/hooks/useRiveString.ts | 2 +- src/hooks/useRiveTrigger.ts | 2 +- src/hooks/useViewModelInstance.ts | 9 +-- tsconfig.json | 3 +- 12 files changed, 73 insertions(+), 49 deletions(-) diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts index e34022fc..17697b06 100644 --- a/example/assets/rive/rewards.riv.d.ts +++ b/example/assets/rive/rewards.riv.d.ts @@ -3,7 +3,14 @@ // Source: rewards.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: 'Main' | 'Lives 2' | 'Item Value' | 'Chest' | 'Button' | 'Heart' | 'Item'; + artboards: + | 'Main' + | 'Lives 2' + | 'Item Value' + | 'Chest' + | 'Button' + | 'Heart' + | 'Item'; defaultArtboard: 'Main'; stateMachines: { 'Main': 'State Machine 1'; @@ -15,36 +22,36 @@ declare const asset: RiveAsset<{ 'Item': 'State Machine 1'; }; viewModels: { - 'Item_Icon_Value': { - 'Icon_React': 'trigger'; - 'Property_Of_Item': 'viewModel:Item'; - 'Item_Value': 'number'; + Item_Icon_Value: { + Icon_React: 'trigger'; + Property_Of_Item: 'viewModel:Item'; + Item_Value: 'number'; }; - 'Energy_Bar': { - 'Bar_Color': 'color'; - 'Lives': 'number'; - 'Energy_Bar': 'number'; + Energy_Bar: { + Bar_Color: 'color'; + Lives: 'number'; + Energy_Bar: 'number'; }; - 'Rewards': { - 'Price_Value': 'number'; - 'Color': 'color'; - 'Height': 'number'; - 'With': 'number'; - 'Item_Selection': 'viewModel:Item'; - 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; - 'Button': 'viewModel:Button'; - 'Coin': 'viewModel:Item_Icon_Value'; - 'Gem': 'viewModel:Item_Icon_Value'; - 'Energy_Bar': 'viewModel:Energy_Bar'; + Rewards: { + Price_Value: 'number'; + Color: 'color'; + Height: 'number'; + With: 'number'; + Item_Selection: 'viewModel:Item'; + Item_Value_Icon: 'viewModel:Item_Icon_Value'; + Button: 'viewModel:Button'; + Coin: 'viewModel:Item_Icon_Value'; + Gem: 'viewModel:Item_Icon_Value'; + Energy_Bar: 'viewModel:Energy_Bar'; }; - 'Button': { - 'State_1': 'string'; - 'Item_Text': 'string'; - 'Item': 'viewModel:Item'; - 'Pressed': 'trigger'; + Button: { + State_1: 'string'; + Item_Text: 'string'; + Item: 'viewModel:Item'; + Pressed: 'trigger'; }; - 'Item': { - 'Item_Selection': 'enum:Coin|Gem'; + Item: { + Item_Selection: 'enum:Coin|Gem'; }; }; }>; diff --git a/example/src/exercisers/RiveDataBindingExample.tsx b/example/src/exercisers/RiveDataBindingExample.tsx index 825c81f7..2c1221e3 100644 --- a/example/src/exercisers/RiveDataBindingExample.tsx +++ b/example/src/exercisers/RiveDataBindingExample.tsx @@ -5,19 +5,23 @@ import { RiveView, useRiveNumber, useViewModelInstance, - type ViewModelInstance, - type RiveFile, + type TypedViewModelInstance, + type TypedRiveFile, useRiveString, useRiveColor, useRiveTrigger, useRiveFile, + type RiveAsset, } from '@rive-app/react-native'; import { type Metadata } from '../shared/metadata'; +import rewardsRiv from '../../assets/rive/rewards.riv'; + +type RewardsSchema = typeof rewardsRiv extends RiveAsset ? T : never; +type RewardsFile = TypedRiveFile; +type RewardsInstance = TypedViewModelInstance; export default function WithRiveFile() { - const { riveFile, isLoading, error } = useRiveFile( - require('../../assets/rive/rewards.riv') - ); + const { riveFile, isLoading, error } = useRiveFile(rewardsRiv); return ( @@ -36,8 +40,10 @@ export default function WithRiveFile() { ); } -function WithViewModelSetup({ file }: { file: RiveFile }) { - const { instance, error } = useViewModelInstance(file); +function WithViewModelSetup({ file }: { file: RewardsFile }) { + const { instance, error } = useViewModelInstance(file, { + viewModelName: 'Rewards', + }); if (error) { console.error(error.message); @@ -55,8 +61,8 @@ function DataBindingExample({ instance, file, }: { - instance: ViewModelInstance; - file: RiveFile; + instance: RewardsInstance; + file: RewardsFile; }) { const { error: coinValueError } = useRiveNumber('Coin/Item_Value', instance); @@ -64,7 +70,10 @@ function DataBindingExample({ console.error('coinValueError', coinValueError); } - const { setValue: setButtonText } = useRiveString('Button/State_1', instance); + const { setValue: setButtonText } = useRiveString( + 'Button/Item_Text', + instance + ); const { setValue: setBarColor, error: barColorError } = useRiveColor( 'Energy_Bar/Bar_Color', diff --git a/scripts/__tests__/rive-extract-schema.test.ts b/scripts/__tests__/rive-extract-schema.test.ts index 0e5fe00f..f3265977 100644 --- a/scripts/__tests__/rive-extract-schema.test.ts +++ b/scripts/__tests__/rive-extract-schema.test.ts @@ -54,7 +54,10 @@ describe('rive-extract-schema', () => { const databinding = extract( resolve(__dirname, '../../example/assets/rive/databinding.riv') ); - const vms = databinding.viewModels as Record>; + const vms = databinding.viewModels as Record< + string, + Record + >; expect(vms.Person!.favourite_pet).toMatch(/^enum:/); expect(vms.Person!.favourite_pet).toContain('chipmunk'); expect(vms.Person!.favourite_pet).toContain('dog'); diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index 32026a93..f297a33d 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -195,4 +195,7 @@ export interface TypedViewModelInstance< > | undefined >; + + /** Brand that prevents typed instances from matching untyped hook overloads. */ + readonly __vmBrand: [T, VMName]; } diff --git a/src/hooks/useRiveBoolean.ts b/src/hooks/useRiveBoolean.ts index 6406c266..3606c92c 100644 --- a/src/hooks/useRiveBoolean.ts +++ b/src/hooks/useRiveBoolean.ts @@ -29,7 +29,7 @@ export function useRiveBoolean< ): UseRivePropertyResult; export function useRiveBoolean( path: string, - viewModelInstance?: ViewModelInstance | null + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null ): UseRivePropertyResult; export function useRiveBoolean( path: string, diff --git a/src/hooks/useRiveColor.ts b/src/hooks/useRiveColor.ts index 247a0d74..8eba97e0 100644 --- a/src/hooks/useRiveColor.ts +++ b/src/hooks/useRiveColor.ts @@ -36,7 +36,7 @@ export function useRiveColor< ): UseRiveColorResult; export function useRiveColor( path: string, - viewModelInstance?: ViewModelInstance | null + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null ): UseRiveColorResult; export function useRiveColor( path: string, diff --git a/src/hooks/useRiveEnum.ts b/src/hooks/useRiveEnum.ts index 710bfd9d..24617b7f 100644 --- a/src/hooks/useRiveEnum.ts +++ b/src/hooks/useRiveEnum.ts @@ -25,7 +25,7 @@ export function useRiveEnum< export function useRiveEnum( path: string, - viewModelInstance?: ViewModelInstance | null + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null ): UseRivePropertyResult; export function useRiveEnum( diff --git a/src/hooks/useRiveNumber.ts b/src/hooks/useRiveNumber.ts index ff8e904c..df45559a 100644 --- a/src/hooks/useRiveNumber.ts +++ b/src/hooks/useRiveNumber.ts @@ -29,7 +29,7 @@ export function useRiveNumber< ): UseRivePropertyResult; export function useRiveNumber( path: string, - viewModelInstance?: ViewModelInstance | null + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null ): UseRivePropertyResult; export function useRiveNumber( path: string, diff --git a/src/hooks/useRiveString.ts b/src/hooks/useRiveString.ts index fe1b0fce..7ff0d200 100644 --- a/src/hooks/useRiveString.ts +++ b/src/hooks/useRiveString.ts @@ -29,7 +29,7 @@ export function useRiveString< ): UseRivePropertyResult; export function useRiveString( path: string, - viewModelInstance?: ViewModelInstance | null + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null ): UseRivePropertyResult; export function useRiveString( path: string, diff --git a/src/hooks/useRiveTrigger.ts b/src/hooks/useRiveTrigger.ts index a600b40d..8dfa92d4 100644 --- a/src/hooks/useRiveTrigger.ts +++ b/src/hooks/useRiveTrigger.ts @@ -36,7 +36,7 @@ export function useRiveTrigger< ): UseRiveTriggerResult; export function useRiveTrigger( path: string, - viewModelInstance?: ViewModelInstance | null, + viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null, params?: UseViewModelInstanceTriggerParameters ): UseRiveTriggerResult; export function useRiveTrigger( diff --git a/src/hooks/useViewModelInstance.ts b/src/hooks/useViewModelInstance.ts index a25d0f85..94601c22 100644 --- a/src/hooks/useViewModelInstance.ts +++ b/src/hooks/useViewModelInstance.ts @@ -272,10 +272,11 @@ export function useViewModelInstance< >( source: TypedRiveFile | null | undefined, params: UseViewModelInstanceFileParams & { viewModelName: N } -): { - instance: TypedViewModelInstance | null | undefined; - error: Error | null; -}; +): + | { instance: TypedViewModelInstance; error: null } + | { instance: null; error: Error } + | { instance: null; error: null } + | { instance: undefined; error: null }; // RiveFile overloads export function useViewModelInstance( diff --git a/tsconfig.json b/tsconfig.json index 6b0104c0..9e098526 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -24,7 +24,8 @@ "skipLibCheck": true, "strict": true, "target": "ESNext", - "verbatimModuleSyntax": true + "verbatimModuleSyntax": true, + "allowArbitraryExtensions": true }, "exclude": ["expo-example", "expo55-example", "**/*.test-d.ts", "scripts/__tests__"] } From aff0862e0d8948845399b21fcd0d91e63fdfe4c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 09:44:27 +0200 Subject: [PATCH 06/24] feat: SchemaOf + TypedViewModelOf so typed params accept typeof import directly --- .../src/exercisers/RiveDataBindingExample.tsx | 8 ++---- src/core/TypedRiveFile.ts | 28 ++++++++++++++++--- src/core/TypedViewModelInstance.ts | 14 +++++++++- src/index.tsx | 2 ++ 4 files changed, 42 insertions(+), 10 deletions(-) diff --git a/example/src/exercisers/RiveDataBindingExample.tsx b/example/src/exercisers/RiveDataBindingExample.tsx index 2c1221e3..73a0b644 100644 --- a/example/src/exercisers/RiveDataBindingExample.tsx +++ b/example/src/exercisers/RiveDataBindingExample.tsx @@ -5,20 +5,18 @@ import { RiveView, useRiveNumber, useViewModelInstance, - type TypedViewModelInstance, + type TypedViewModelOf, type TypedRiveFile, useRiveString, useRiveColor, useRiveTrigger, useRiveFile, - type RiveAsset, } from '@rive-app/react-native'; import { type Metadata } from '../shared/metadata'; import rewardsRiv from '../../assets/rive/rewards.riv'; -type RewardsSchema = typeof rewardsRiv extends RiveAsset ? T : never; -type RewardsFile = TypedRiveFile; -type RewardsInstance = TypedViewModelInstance; +type RewardsFile = TypedRiveFile; +type RewardsInstance = TypedViewModelOf; export default function WithRiveFile() { const { riveFile, isLoading, error } = useRiveFile(rewardsRiv); diff --git a/src/core/TypedRiveFile.ts b/src/core/TypedRiveFile.ts index 22ba97f9..82ae93f1 100644 --- a/src/core/TypedRiveFile.ts +++ b/src/core/TypedRiveFile.ts @@ -31,14 +31,34 @@ export type RiveAsset = number & { readonly __riveSchema?: T; }; +/** + * Extracts the RiveFileSchema from a RiveAsset, TypedRiveFile, or a bare RiveFileSchema. + * + * @example + * import rewardsRiv from './rewards.riv'; + * type Schema = SchemaOf; // RewardsSchema + */ +export type SchemaOf = T extends { + readonly __riveSchema?: infer S extends RiveFileSchema; +} + ? S + : T extends { readonly __schema?: infer S extends RiveFileSchema } + ? S + : T extends RiveFileSchema + ? T + : never; + /** * A RiveFile branded with a schema type `T`. * The `__schema` field is purely a phantom type — it never exists at runtime. * + * Accepts either a `RiveFileSchema` or a `RiveAsset` (i.e. `typeof myRiv`). + * * Obtain one via `RiveFileFactory.fromURL(...)` or * `RiveFileFactory.fromSource(typedAsset)`. */ -export type TypedRiveFile = - RiveFile & { - readonly __schema?: T; - }; +export type TypedRiveFile< + T extends RiveFileSchema | RiveAsset = RiveFileSchema, +> = RiveFile & { + readonly __schema?: SchemaOf; +}; diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index f297a33d..87c7542c 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -9,7 +9,7 @@ import type { ViewModelImageProperty, ViewModelListProperty, } from '../specs/ViewModel.nitro'; -import type { RiveFileSchema } from './TypedRiveFile'; +import type { RiveAsset, RiveFileSchema, SchemaOf } from './TypedRiveFile'; /** * A typed list property whose elements are ViewModelInstances from the same file. @@ -199,3 +199,15 @@ export interface TypedViewModelInstance< /** Brand that prevents typed instances from matching untyped hook overloads. */ readonly __vmBrand: [T, VMName]; } + +/** + * Convenience alias: infer the ViewModel instance type directly from a RiveAsset import. + * + * @example + * import rewardsRiv from './rewards.riv'; + * type RewardsInstance = TypedViewModelOf; + */ +export type TypedViewModelOf< + T extends RiveFileSchema | RiveAsset, + VMName extends Extract['viewModels'], string>, +> = TypedViewModelInstance, VMName>; diff --git a/src/index.tsx b/src/index.tsx index 7d0ba36e..726fffcf 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -23,10 +23,12 @@ export type { RiveFile } from './specs/RiveFile.nitro'; export type { RiveAsset, RiveFileSchema, + SchemaOf, TypedRiveFile, } from './core/TypedRiveFile'; export type { TypedViewModelInstance, + TypedViewModelOf, TypedViewModelListProperty, TypedViewModelEnumProperty, PathsOfKind, From f5b2d967228a8f73a4b4ca86ae44d9ade922a9d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 09:49:44 +0200 Subject: [PATCH 07/24] chore: use structural __schema inference in useViewModelInstance typed overload --- example/src/exercisers/RiveDataBindingExample.tsx | 15 ++++++++------- src/hooks/useViewModelInstance.ts | 4 ++-- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/example/src/exercisers/RiveDataBindingExample.tsx b/example/src/exercisers/RiveDataBindingExample.tsx index 73a0b644..3b6ebc06 100644 --- a/example/src/exercisers/RiveDataBindingExample.tsx +++ b/example/src/exercisers/RiveDataBindingExample.tsx @@ -15,9 +15,6 @@ import { import { type Metadata } from '../shared/metadata'; import rewardsRiv from '../../assets/rive/rewards.riv'; -type RewardsFile = TypedRiveFile; -type RewardsInstance = TypedViewModelOf; - export default function WithRiveFile() { const { riveFile, isLoading, error } = useRiveFile(rewardsRiv); @@ -38,14 +35,18 @@ export default function WithRiveFile() { ); } -function WithViewModelSetup({ file }: { file: RewardsFile }) { +function WithViewModelSetup({ + file, +}: { + file: TypedRiveFile; +}) { const { instance, error } = useViewModelInstance(file, { viewModelName: 'Rewards', }); if (error) { console.error(error.message); - return {error.message}; + return {error.message}; } if (!instance) { @@ -59,8 +60,8 @@ function DataBindingExample({ instance, file, }: { - instance: RewardsInstance; - file: RewardsFile; + instance: TypedViewModelOf; + file: TypedRiveFile; }) { const { error: coinValueError } = useRiveNumber('Coin/Item_Value', instance); diff --git a/src/hooks/useViewModelInstance.ts b/src/hooks/useViewModelInstance.ts index 94601c22..007c870a 100644 --- a/src/hooks/useViewModelInstance.ts +++ b/src/hooks/useViewModelInstance.ts @@ -3,7 +3,7 @@ import { useMemo, useRef } from 'react'; import type { ViewModel, ViewModelInstance } from '../specs/ViewModel.nitro'; import type { RiveFile } from '../specs/RiveFile.nitro'; -import type { RiveFileSchema, TypedRiveFile } from '../core/TypedRiveFile'; +import type { RiveFileSchema } from '../core/TypedRiveFile'; import type { TypedViewModelInstance } from '../core/TypedViewModelInstance'; import type { RiveViewRef } from '../index'; import { callDispose } from '../core/callDispose'; @@ -270,7 +270,7 @@ export function useViewModelInstance< T extends RiveFileSchema, N extends Extract, >( - source: TypedRiveFile | null | undefined, + source: (RiveFile & { readonly __schema?: T }) | null | undefined, params: UseViewModelInstanceFileParams & { viewModelName: N } ): | { instance: TypedViewModelInstance; error: null } From 4ccfd4f6527117e6a1b4253963f2856ac3ae871e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 10:32:09 +0200 Subject: [PATCH 08/24] chore: name the untyped overload brand as UntypedViewModelInstance --- src/core/TypedViewModelInstance.ts | 7 +++++++ src/hooks/useRiveBoolean.ts | 3 ++- src/hooks/useRiveColor.ts | 3 ++- src/hooks/useRiveEnum.ts | 3 ++- src/hooks/useRiveNumber.ts | 3 ++- src/hooks/useRiveString.ts | 3 ++- src/hooks/useRiveTrigger.ts | 3 ++- src/index.tsx | 1 + 8 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index 87c7542c..db6ae27b 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -200,6 +200,13 @@ export interface TypedViewModelInstance< readonly __vmBrand: [T, VMName]; } +/** + * A plain ViewModelInstance with no schema type information. + * Used in the untyped hook overloads — typed instances are intentionally + * excluded so TypeScript picks the typed overload when a schema is known. + */ +export type UntypedViewModelInstance = ViewModelInstance & { __vmBrand?: never }; + /** * Convenience alias: infer the ViewModel instance type directly from a RiveAsset import. * diff --git a/src/hooks/useRiveBoolean.ts b/src/hooks/useRiveBoolean.ts index 3606c92c..f6449aa0 100644 --- a/src/hooks/useRiveBoolean.ts +++ b/src/hooks/useRiveBoolean.ts @@ -7,6 +7,7 @@ import { useRiveProperty } from './useRiveProperty'; import type { PathsOfKind, TypedViewModelInstance, + UntypedViewModelInstance, } from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; @@ -29,7 +30,7 @@ export function useRiveBoolean< ): UseRivePropertyResult; export function useRiveBoolean( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null + viewModelInstance?: UntypedViewModelInstance | null ): UseRivePropertyResult; export function useRiveBoolean( path: string, diff --git a/src/hooks/useRiveColor.ts b/src/hooks/useRiveColor.ts index 8eba97e0..f16ccfd8 100644 --- a/src/hooks/useRiveColor.ts +++ b/src/hooks/useRiveColor.ts @@ -8,6 +8,7 @@ import { RiveColor } from '../core/RiveColor'; import type { PathsOfKind, TypedViewModelInstance, + UntypedViewModelInstance, } from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; @@ -36,7 +37,7 @@ export function useRiveColor< ): UseRiveColorResult; export function useRiveColor( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null + viewModelInstance?: UntypedViewModelInstance | null ): UseRiveColorResult; export function useRiveColor( path: string, diff --git a/src/hooks/useRiveEnum.ts b/src/hooks/useRiveEnum.ts index 24617b7f..11ba2b3a 100644 --- a/src/hooks/useRiveEnum.ts +++ b/src/hooks/useRiveEnum.ts @@ -7,6 +7,7 @@ import type { RiveFileSchema } from '../core/TypedRiveFile'; import { type EnumValuesOf, type TypedViewModelInstance, + type UntypedViewModelInstance, type VMPropsOfKind, } from '../core/TypedViewModelInstance'; import { useRiveProperty } from './useRiveProperty'; @@ -25,7 +26,7 @@ export function useRiveEnum< export function useRiveEnum( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null + viewModelInstance?: UntypedViewModelInstance | null ): UseRivePropertyResult; export function useRiveEnum( diff --git a/src/hooks/useRiveNumber.ts b/src/hooks/useRiveNumber.ts index df45559a..4cda0bb0 100644 --- a/src/hooks/useRiveNumber.ts +++ b/src/hooks/useRiveNumber.ts @@ -7,6 +7,7 @@ import { useRiveProperty } from './useRiveProperty'; import type { PathsOfKind, TypedViewModelInstance, + UntypedViewModelInstance, } from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; @@ -29,7 +30,7 @@ export function useRiveNumber< ): UseRivePropertyResult; export function useRiveNumber( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null + viewModelInstance?: UntypedViewModelInstance | null ): UseRivePropertyResult; export function useRiveNumber( path: string, diff --git a/src/hooks/useRiveString.ts b/src/hooks/useRiveString.ts index 7ff0d200..c5210e2a 100644 --- a/src/hooks/useRiveString.ts +++ b/src/hooks/useRiveString.ts @@ -7,6 +7,7 @@ import { useRiveProperty } from './useRiveProperty'; import type { PathsOfKind, TypedViewModelInstance, + UntypedViewModelInstance, } from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; @@ -29,7 +30,7 @@ export function useRiveString< ): UseRivePropertyResult; export function useRiveString( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null + viewModelInstance?: UntypedViewModelInstance | null ): UseRivePropertyResult; export function useRiveString( path: string, diff --git a/src/hooks/useRiveTrigger.ts b/src/hooks/useRiveTrigger.ts index 8dfa92d4..9ca2c22d 100644 --- a/src/hooks/useRiveTrigger.ts +++ b/src/hooks/useRiveTrigger.ts @@ -11,6 +11,7 @@ import { useDisposableMemo } from './useDisposableMemo'; import type { PathsOfKind, TypedViewModelInstance, + UntypedViewModelInstance, } from '../core/TypedViewModelInstance'; import type { RiveFileSchema } from '../core/TypedRiveFile'; @@ -36,7 +37,7 @@ export function useRiveTrigger< ): UseRiveTriggerResult; export function useRiveTrigger( path: string, - viewModelInstance?: (ViewModelInstance & { __vmBrand?: never }) | null, + viewModelInstance?: UntypedViewModelInstance | null, params?: UseViewModelInstanceTriggerParameters ): UseRiveTriggerResult; export function useRiveTrigger( diff --git a/src/index.tsx b/src/index.tsx index 726fffcf..0000d19c 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -29,6 +29,7 @@ export type { export type { TypedViewModelInstance, TypedViewModelOf, + UntypedViewModelInstance, TypedViewModelListProperty, TypedViewModelEnumProperty, PathsOfKind, From 54e7e77e5671aecd23e5a7b8d547138ab9e4f4fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 10:49:17 +0200 Subject: [PATCH 09/24] chore: add type tests for useRiveNumber hook --- src/__tests__/typed-rive.test-d.ts | 46 ++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/src/__tests__/typed-rive.test-d.ts b/src/__tests__/typed-rive.test-d.ts index 47b661b4..b62232ef 100644 --- a/src/__tests__/typed-rive.test-d.ts +++ b/src/__tests__/typed-rive.test-d.ts @@ -4,12 +4,16 @@ import type { TypedViewModelInstance, TypedViewModelListProperty, TypedViewModelEnumProperty, + UntypedViewModelInstance, } from '../../src/core/TypedViewModelInstance'; import type { + ViewModelInstance, ViewModelNumberProperty, ViewModelTriggerProperty, ViewModelBooleanProperty, } from '../../src/specs/ViewModel.nitro'; +import type { UseRivePropertyResult } from '../../src/types'; +import { useRiveNumber } from '../../src/hooks/useRiveNumber'; import type { RiveViewProps } from '../../src/core/RiveView'; import gradientBorderRiv from '../../example/assets/rive/GradientBorder.riv'; import blinkoRiv from '../../example/assets/rive/blinko.riv'; @@ -226,3 +230,45 @@ type AnyBlinkoVM = TypedViewModelInstance< >; declare const list: TypedViewModelListProperty; expectAssignable>(list.getInstanceAtAsync(0)); + +// ============================================================ +// useRiveNumber +// ============================================================ + +declare const untypedInstance: UntypedViewModelInstance; +declare const plainInstance: ViewModelInstance; + +// Typed overload: valid direct number path → result typed as number +expectType>( + useRiveNumber('multiplierValue', storeVM) +); + +// Typed overload: valid nested number path (nested ViewModel) +expectType>( + useRiveNumber('property of pegVM/multiplierValue', storeVM) +); + +// Typed overload: wrong kind — xbuttonClick is a trigger, not a number +expectError(useRiveNumber('xbuttonClick', storeVM)); + +// Typed overload: nonexistent path +expectError(useRiveNumber('doesNotExist', storeVM)); + +// Typed overload: nested path with wrong property kind +expectError(useRiveNumber('property of pegVM/blink', storeVM)); + +// Typed instance rejected by untyped overload → forces typed overload → wrong path errors +expectError(useRiveNumber('multiplierValue' as string, storeVM)); + +// Untyped overload: plain ViewModelInstance accepts any string path +expectType>( + useRiveNumber('any/path', untypedInstance) +); + +// Untyped overload: plain ViewModelInstance (no brand) also accepted +expectType>( + useRiveNumber('any/path', plainInstance) +); + +// No instance: falls back to untyped overload, still returns number result +expectType>(useRiveNumber('multiplierValue')); From 6cbfd72a7fbfd3068e36d61ebeca9fe8bb511fe1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:00:46 +0200 Subject: [PATCH 10/24] chore: validate .riv schema files are up-to-date in CI --- .github/actions/setup/action.yml | 3 +++ .github/workflows/ci.yml | 8 ++++++++ 2 files changed, 11 insertions(+) diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml index 066f4f5e..eb63fb47 100644 --- a/.github/actions/setup/action.yml +++ b/.github/actions/setup/action.yml @@ -9,6 +9,9 @@ runs: with: node-version-file: .nvmrc + - name: Setup Bun + uses: oven-sh/setup-bun@v2 + - name: Restore dependencies id: yarn-cache uses: actions/cache/restore@v4 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3b370329..9a7f1d8e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -54,6 +54,14 @@ jobs: exit 1 fi + - name: Validate .riv schema files + run: | + yarn rive-gen-types --all example/assets/rive + if ! git diff --exit-code 'example/assets/rive/*.riv.d.ts'; then + echo "Error: .riv.d.ts files are out of date. Please run 'yarn rive-gen-types --all example/assets/rive' and commit the changes." + exit 1 + fi + - name: Typecheck files run: yarn typecheck From 5e05c0a10567f0108814f1f20cf5d3e99c470d03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:20:05 +0200 Subject: [PATCH 11/24] fix: restore number overload on fromSource to preserve backward compat --- src/core/RiveFile.ts | 12 +++++++++++- src/core/TypedViewModelInstance.ts | 4 +++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/src/core/RiveFile.ts b/src/core/RiveFile.ts index d9229587..1c991abe 100644 --- a/src/core/RiveFile.ts +++ b/src/core/RiveFile.ts @@ -83,8 +83,18 @@ export namespace RiveFileFactory { * config.resolver.assetExts = [...config.resolver.assetExts, 'riv']; * ``` */ + export async function fromSource( + source: RiveAsset, + referencedAssets: ResolvedReferencedAssets | undefined, + loadCdn?: boolean + ): Promise>; + export async function fromSource( + source: number | { uri: string }, + referencedAssets: ResolvedReferencedAssets | undefined, + loadCdn?: boolean + ): Promise; export async function fromSource( - source: RiveAsset | { uri: string }, + source: number | { uri: string }, referencedAssets: ResolvedReferencedAssets | undefined, loadCdn: boolean = true ): Promise> { diff --git a/src/core/TypedViewModelInstance.ts b/src/core/TypedViewModelInstance.ts index db6ae27b..1230b67c 100644 --- a/src/core/TypedViewModelInstance.ts +++ b/src/core/TypedViewModelInstance.ts @@ -205,7 +205,9 @@ export interface TypedViewModelInstance< * Used in the untyped hook overloads — typed instances are intentionally * excluded so TypeScript picks the typed overload when a schema is known. */ -export type UntypedViewModelInstance = ViewModelInstance & { __vmBrand?: never }; +export type UntypedViewModelInstance = ViewModelInstance & { + __vmBrand?: never; +}; /** * Convenience alias: infer the ViewModel instance type directly from a RiveAsset import. From 448d96082cd7bfd39cf43e871b5c627f663b4a2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:21:37 +0200 Subject: [PATCH 12/24] fix: use spawnSync argv array instead of execSync shell string --- scripts/rive-gen-types.ts | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index 2a1fa6d9..f98116c3 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -13,7 +13,7 @@ * const file = await RiveFileFactory.fromSource(gameRiv); // TypedRiveFile — T inferred */ -import { execSync } from 'child_process'; +import { spawnSync } from 'child_process'; import { writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'; import { dirname, resolve, basename, extname } from 'path'; import { fileURLToPath } from 'url'; @@ -31,11 +31,16 @@ interface Schema { function extractSchema(input: string): Schema { for (let attempt = 0; attempt < 2; attempt++) { try { - const json = execSync(`bun "${extractorPath}" "${input}"`, { + const result = spawnSync('bun', [extractorPath, input], { encoding: 'utf8', timeout: 30_000, }); - return JSON.parse(json) as Schema; + if (result.error) throw result.error; + if (result.status !== 0) + throw new Error( + result.stderr || `bun exited with code ${result.status}` + ); + return JSON.parse(result.stdout) as Schema; } catch (err) { if (attempt === 1) throw err; } From bcebc3e9190bfca4a84c067a44e58fa02fc5af54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:23:08 +0200 Subject: [PATCH 13/24] fix: error on URL input without --out instead of producing an invalid path --- scripts/rive-gen-types.ts | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index f98116c3..bfb08b5b 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -200,6 +200,13 @@ if (outIdx !== -1) { : baseName.charAt(0).toUpperCase() + baseName.slice(1) + 'Schema'; generate(input, outPath, 'standalone', typeName); } else { + if (input.startsWith('http://') || input.startsWith('https://')) { + process.stderr.write( + `Error: URL inputs require --out to specify the output path.\n` + + ` Example: rive-gen-types ${input} --out ./assets/file.riv.d.ts\n` + ); + process.exit(1); + } // Default: write .riv.d.ts next to the source file const absInput = resolve(process.cwd(), input); generate(input, `${absInput}.d.ts`, 'dts'); From 7bd30a7876f35460a4a107a1b80bc8dde4b0604e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:38:02 +0200 Subject: [PATCH 14/24] chore: regenerate .riv.d.ts files with quoted property keys --- example/assets/rive/GradientBorder.riv.d.ts | 6 +- example/assets/rive/artboard_db_test.riv.d.ts | 14 +-- example/assets/rive/blinko.riv.d.ts | 114 ++++++++---------- example/assets/rive/bouncing_ball.riv.d.ts | 6 +- example/assets/rive/counter.riv.d.ts | 6 +- example/assets/rive/databinding.riv.d.ts | 26 ++-- .../assets/rive/databinding_images.riv.d.ts | 6 +- .../assets/rive/databinding_lists.riv.d.ts | 10 +- example/assets/rive/fallback_fonts.riv.d.ts | 2 +- example/assets/rive/font_fallback.riv.d.ts | 6 +- example/assets/rive/inputglow.riv.d.ts | 6 +- .../ios_android_layouts_demo_v01.riv.d.ts | 2 +- example/assets/rive/layout_test.riv.d.ts | 6 +- example/assets/rive/layouts_demo.riv.d.ts | 2 +- example/assets/rive/many_viewmodels.riv.d.ts | 10 +- example/assets/rive/movecircle.riv.d.ts | 6 +- .../assets/rive/nodefaultbouncing.riv.d.ts | 6 +- example/assets/rive/on_entry_test.riv.d.ts | 8 +- example/assets/rive/out_of_band.riv.d.ts | 2 +- example/assets/rive/quick_start.riv.d.ts | 14 +-- example/assets/rive/rewards.riv.d.ts | 61 +++++----- .../assets/rive/style_fallback_fonts.riv.d.ts | 2 +- .../assets/rive/viewmodelproperty.riv.d.ts | 12 +- .../assets/rive/vm_value_change_test.riv.d.ts | 8 +- 24 files changed, 165 insertions(+), 176 deletions(-) diff --git a/example/assets/rive/GradientBorder.riv.d.ts b/example/assets/rive/GradientBorder.riv.d.ts index a964f379..3fdc9e8e 100644 --- a/example/assets/rive/GradientBorder.riv.d.ts +++ b/example/assets/rive/GradientBorder.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - Layout: 'State'; + 'Layout': 'State'; }; viewModels: { - ViewModel: { - isFocused: 'boolean'; + 'ViewModel': { + 'isFocused': 'boolean'; }; }; }>; diff --git a/example/assets/rive/artboard_db_test.riv.d.ts b/example/assets/rive/artboard_db_test.riv.d.ts index 6b8b0eb6..33d2c567 100644 --- a/example/assets/rive/artboard_db_test.riv.d.ts +++ b/example/assets/rive/artboard_db_test.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Main' | 'ArtboardGreen' | 'ArtboardBlue' | 'ArtboardRed'; defaultArtboard: 'Main'; stateMachines: { - Main: 'State Machine 1'; - ArtboardGreen: 'State Machine 1'; - ArtboardBlue: 'State Machine 1'; - ArtboardRed: 'State Machine 1'; + 'Main': 'State Machine 1'; + 'ArtboardGreen': 'State Machine 1'; + 'ArtboardBlue': 'State Machine 1'; + 'ArtboardRed': 'State Machine 1'; }; viewModels: { - MainViewModel: { - artboard_1: 'artboard'; - artboard_2: 'artboard'; + 'MainViewModel': { + 'artboard_1': 'artboard'; + 'artboard_2': 'artboard'; }; }; }>; diff --git a/example/assets/rive/blinko.riv.d.ts b/example/assets/rive/blinko.riv.d.ts index 7070d1d2..ccc3476b 100644 --- a/example/assets/rive/blinko.riv.d.ts +++ b/example/assets/rive/blinko.riv.d.ts @@ -3,48 +3,40 @@ // Source: blinko.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: - | 'Main' - | 'StoreItem' - | 'Token' - | 'Indicator' - | 'Puck' - | 'StoreIcon' - | 'Peg' - | 'scoreBox'; + artboards: 'Main' | 'StoreItem' | 'Token' | 'Indicator' | 'Puck' | 'StoreIcon' | 'Peg' | 'scoreBox'; defaultArtboard: 'Main'; stateMachines: { - Main: 'State Machine 1'; - StoreItem: 'State Machine 1'; - Token: 'State Machine 1'; - Indicator: 'State Machine 1'; - Puck: 'State Machine 1'; - StoreIcon: 'State Machine 1'; - Peg: 'State Machine 1'; - scoreBox: 'State Machine 1'; + 'Main': 'State Machine 1'; + 'StoreItem': 'State Machine 1'; + 'Token': 'State Machine 1'; + 'Indicator': 'State Machine 1'; + 'Puck': 'State Machine 1'; + 'StoreIcon': 'State Machine 1'; + 'Peg': 'State Machine 1'; + 'scoreBox': 'State Machine 1'; }; viewModels: { - IndicatorVM: { - purchased: 'boolean'; + 'IndicatorVM': { + 'purchased': 'boolean'; }; - StoreItemVM: { - tokenCount: 'number'; - height: 'number'; - itemHover: 'boolean'; - cost: 'number'; - description: 'string'; - id: 'string'; - itemType: 'string'; - maxPurchases: 'number'; - name: 'string'; - purchase: 'trigger'; - purchaseCount: 'number'; + 'StoreItemVM': { + 'tokenCount': 'number'; + 'height': 'number'; + 'itemHover': 'boolean'; + 'cost': 'number'; + 'description': 'string'; + 'id': 'string'; + 'itemType': 'string'; + 'maxPurchases': 'number'; + 'name': 'string'; + 'purchase': 'trigger'; + 'purchaseCount': 'number'; }; - storeIconVM: { - storeiconClick: 'trigger'; - iconHovered: 'boolean'; + 'storeIconVM': { + 'storeiconClick': 'trigger'; + 'iconHovered': 'boolean'; }; - storeVM: { + 'storeVM': { 'xbuttonClick': 'trigger'; 'xbuttonHover': 'boolean'; 'items': 'list'; @@ -60,37 +52,37 @@ declare const asset: RiveAsset<{ 'superMultiplierCost': 'number'; 'superMultiplierCount': 'number'; }; - TokenVM: { - spinToken: 'boolean'; + 'TokenVM': { + 'spinToken': 'boolean'; }; - pegVM: { - blink: 'trigger'; - multiplierValue: 'number'; - pegType: 'enum:normal|multiplier'; - pegBounced: 'trigger'; + 'pegVM': { + 'blink': 'trigger'; + 'multiplierValue': 'number'; + 'pegType': 'enum:normal|multiplier'; + 'pegBounced': 'trigger'; }; - gameLogicVM: { - turnTokens: 'number'; - turnScore: 'number'; - buttonLabel: 'string'; - message: 'string'; - startTurn: 'trigger'; - turnEnded: 'trigger'; - gameEnded: 'boolean'; - tokenCount: 'number'; - scoreTotal: 'number'; + 'gameLogicVM': { + 'turnTokens': 'number'; + 'turnScore': 'number'; + 'buttonLabel': 'string'; + 'message': 'string'; + 'startTurn': 'trigger'; + 'turnEnded': 'trigger'; + 'gameEnded': 'boolean'; + 'tokenCount': 'number'; + 'scoreTotal': 'number'; }; - scoreBox: { - Token: 'viewModel:TokenVM'; - slotType: 'enum:addToken|normal'; - landed: 'trigger'; - scoreValue: 'number'; + 'scoreBox': { + 'Token': 'viewModel:TokenVM'; + 'slotType': 'enum:addToken|normal'; + 'landed': 'trigger'; + 'scoreValue': 'number'; }; - PuckVM: { - puckBounce: 'trigger'; - puckRotation: 'number'; + 'PuckVM': { + 'puckBounce': 'trigger'; + 'puckRotation': 'number'; }; - main: { + 'main': { 'PuckVM': 'viewModel:PuckVM'; 'storeItemVM': 'viewModel:StoreItemVM'; 'storeIconVM': 'viewModel:storeIconVM'; diff --git a/example/assets/rive/bouncing_ball.riv.d.ts b/example/assets/rive/bouncing_ball.riv.d.ts index 10bc5f04..b6d2574d 100644 --- a/example/assets/rive/bouncing_ball.riv.d.ts +++ b/example/assets/rive/bouncing_ball.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - vm: { - ypos: 'number'; + 'vm': { + 'ypos': 'number'; }; }; }>; diff --git a/example/assets/rive/counter.riv.d.ts b/example/assets/rive/counter.riv.d.ts index 244bbe14..b1ba266a 100644 --- a/example/assets/rive/counter.riv.d.ts +++ b/example/assets/rive/counter.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - ViewModel1: { - cnt: 'number'; + 'ViewModel1': { + 'cnt': 'number'; }; }; }>; diff --git a/example/assets/rive/databinding.riv.d.ts b/example/assets/rive/databinding.riv.d.ts index f0b630e5..d8d93c3c 100644 --- a/example/assets/rive/databinding.riv.d.ts +++ b/example/assets/rive/databinding.riv.d.ts @@ -6,22 +6,22 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - Person: { - pet: 'viewModel:Pet'; - jump: 'trigger'; - likes_popcorn: 'boolean'; - favourite_pet: 'enum:chipmunk|rat|frog|owl|cat|dog'; - favourite_color: 'color'; - age: 'number'; - website: 'string'; - name: 'string'; + 'Person': { + 'pet': 'viewModel:Pet'; + 'jump': 'trigger'; + 'likes_popcorn': 'boolean'; + 'favourite_pet': 'enum:chipmunk|rat|frog|owl|cat|dog'; + 'favourite_color': 'color'; + 'age': 'number'; + 'website': 'string'; + 'name': 'string'; }; - Pet: { - type: 'enum:chipmunk|rat|frog|owl|cat|dog'; - name: 'string'; + 'Pet': { + 'type': 'enum:chipmunk|rat|frog|owl|cat|dog'; + 'name': 'string'; }; }; }>; diff --git a/example/assets/rive/databinding_images.riv.d.ts b/example/assets/rive/databinding_images.riv.d.ts index b9d93374..6d788405 100644 --- a/example/assets/rive/databinding_images.riv.d.ts +++ b/example/assets/rive/databinding_images.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - MyViewModel: { - bound_image: 'image'; + 'MyViewModel': { + 'bound_image': 'image'; }; }; }>; diff --git a/example/assets/rive/databinding_lists.riv.d.ts b/example/assets/rive/databinding_lists.riv.d.ts index 00334476..75795551 100644 --- a/example/assets/rive/databinding_lists.riv.d.ts +++ b/example/assets/rive/databinding_lists.riv.d.ts @@ -6,14 +6,14 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - Person: { - name: 'string'; + 'Person': { + 'name': 'string'; }; - DevRel: { - team: 'list'; + 'DevRel': { + 'team': 'list'; }; }; }>; diff --git a/example/assets/rive/fallback_fonts.riv.d.ts b/example/assets/rive/fallback_fonts.riv.d.ts index 60e8aa1d..ab210750 100644 --- a/example/assets/rive/fallback_fonts.riv.d.ts +++ b/example/assets/rive/fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/font_fallback.riv.d.ts b/example/assets/rive/font_fallback.riv.d.ts index 02bdda87..367dd2ab 100644 --- a/example/assets/rive/font_fallback.riv.d.ts +++ b/example/assets/rive/font_fallback.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - ViewModel: { - text: 'string'; + 'ViewModel': { + 'text': 'string'; }; }; }>; diff --git a/example/assets/rive/inputglow.riv.d.ts b/example/assets/rive/inputglow.riv.d.ts index c1a84c21..3b51f663 100644 --- a/example/assets/rive/inputglow.riv.d.ts +++ b/example/assets/rive/inputglow.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - Layout: 'State'; + 'Layout': 'State'; }; viewModels: { - ViewModel: { - isFocused: 'boolean'; + 'ViewModel': { + 'isFocused': 'boolean'; }; }; }>; diff --git a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts index 549ba94c..80be047c 100644 --- a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts +++ b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - iOS_Android_Layouts_demo_v01: 'State Machine 1'; + 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/layout_test.riv.d.ts b/example/assets/rive/layout_test.riv.d.ts index b513d8b8..008fd913 100644 --- a/example/assets/rive/layout_test.riv.d.ts +++ b/example/assets/rive/layout_test.riv.d.ts @@ -6,10 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - ViewModel1: {}; + 'ViewModel1': { + + }; }; }>; export default asset; diff --git a/example/assets/rive/layouts_demo.riv.d.ts b/example/assets/rive/layouts_demo.riv.d.ts index ac330ad0..a5587ce3 100644 --- a/example/assets/rive/layouts_demo.riv.d.ts +++ b/example/assets/rive/layouts_demo.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - iOS_Android_Layouts_demo_v01: 'State Machine 1'; + 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/many_viewmodels.riv.d.ts b/example/assets/rive/many_viewmodels.riv.d.ts index 4e717058..2a890294 100644 --- a/example/assets/rive/many_viewmodels.riv.d.ts +++ b/example/assets/rive/many_viewmodels.riv.d.ts @@ -6,13 +6,13 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - First: { - imageValue: 'image'; - colorValue: 'color'; - textValue: 'string'; + 'First': { + 'imageValue': 'image'; + 'colorValue': 'color'; + 'textValue': 'string'; }; }; }>; diff --git a/example/assets/rive/movecircle.riv.d.ts b/example/assets/rive/movecircle.riv.d.ts index 229ae35c..f63db94b 100644 --- a/example/assets/rive/movecircle.riv.d.ts +++ b/example/assets/rive/movecircle.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - ViewModel: { - posY: 'number'; + 'ViewModel': { + 'posY': 'number'; }; }; }>; diff --git a/example/assets/rive/nodefaultbouncing.riv.d.ts b/example/assets/rive/nodefaultbouncing.riv.d.ts index cabe01ee..9a16de8e 100644 --- a/example/assets/rive/nodefaultbouncing.riv.d.ts +++ b/example/assets/rive/nodefaultbouncing.riv.d.ts @@ -6,10 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - VM1: {}; + 'VM1': { + + }; }; }>; export default asset; diff --git a/example/assets/rive/on_entry_test.riv.d.ts b/example/assets/rive/on_entry_test.riv.d.ts index 56b087dc..81e4ef07 100644 --- a/example/assets/rive/on_entry_test.riv.d.ts +++ b/example/assets/rive/on_entry_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - vm: { - input: 'number'; - inputOnEntry: 'number'; + 'vm': { + 'input': 'number'; + 'inputOnEntry': 'number'; }; }; }>; diff --git a/example/assets/rive/out_of_band.riv.d.ts b/example/assets/rive/out_of_band.riv.d.ts index 9546dc6a..8b22e950 100644 --- a/example/assets/rive/out_of_band.riv.d.ts +++ b/example/assets/rive/out_of_band.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/quick_start.riv.d.ts b/example/assets/rive/quick_start.riv.d.ts index 4847c6a7..b3abbe6b 100644 --- a/example/assets/rive/quick_start.riv.d.ts +++ b/example/assets/rive/quick_start.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'health_bar_v01'; defaultArtboard: 'health_bar_v01'; stateMachines: { - health_bar_v01: 'State Machine 1'; + 'health_bar_v01': 'State Machine 1'; }; viewModels: { - health_bar_01: { - gameOver: 'trigger'; - hoverYes: 'boolean'; - hoverNo: 'boolean'; - healthColor: 'color'; - health: 'number'; + 'health_bar_01': { + 'gameOver': 'trigger'; + 'hoverYes': 'boolean'; + 'hoverNo': 'boolean'; + 'healthColor': 'color'; + 'health': 'number'; }; }; }>; diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts index 17697b06..e34022fc 100644 --- a/example/assets/rive/rewards.riv.d.ts +++ b/example/assets/rive/rewards.riv.d.ts @@ -3,14 +3,7 @@ // Source: rewards.riv import type { RiveAsset } from '@rive-app/react-native'; declare const asset: RiveAsset<{ - artboards: - | 'Main' - | 'Lives 2' - | 'Item Value' - | 'Chest' - | 'Button' - | 'Heart' - | 'Item'; + artboards: 'Main' | 'Lives 2' | 'Item Value' | 'Chest' | 'Button' | 'Heart' | 'Item'; defaultArtboard: 'Main'; stateMachines: { 'Main': 'State Machine 1'; @@ -22,36 +15,36 @@ declare const asset: RiveAsset<{ 'Item': 'State Machine 1'; }; viewModels: { - Item_Icon_Value: { - Icon_React: 'trigger'; - Property_Of_Item: 'viewModel:Item'; - Item_Value: 'number'; + 'Item_Icon_Value': { + 'Icon_React': 'trigger'; + 'Property_Of_Item': 'viewModel:Item'; + 'Item_Value': 'number'; }; - Energy_Bar: { - Bar_Color: 'color'; - Lives: 'number'; - Energy_Bar: 'number'; + 'Energy_Bar': { + 'Bar_Color': 'color'; + 'Lives': 'number'; + 'Energy_Bar': 'number'; }; - Rewards: { - Price_Value: 'number'; - Color: 'color'; - Height: 'number'; - With: 'number'; - Item_Selection: 'viewModel:Item'; - Item_Value_Icon: 'viewModel:Item_Icon_Value'; - Button: 'viewModel:Button'; - Coin: 'viewModel:Item_Icon_Value'; - Gem: 'viewModel:Item_Icon_Value'; - Energy_Bar: 'viewModel:Energy_Bar'; + 'Rewards': { + 'Price_Value': 'number'; + 'Color': 'color'; + 'Height': 'number'; + 'With': 'number'; + 'Item_Selection': 'viewModel:Item'; + 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; + 'Button': 'viewModel:Button'; + 'Coin': 'viewModel:Item_Icon_Value'; + 'Gem': 'viewModel:Item_Icon_Value'; + 'Energy_Bar': 'viewModel:Energy_Bar'; }; - Button: { - State_1: 'string'; - Item_Text: 'string'; - Item: 'viewModel:Item'; - Pressed: 'trigger'; + 'Button': { + 'State_1': 'string'; + 'Item_Text': 'string'; + 'Item': 'viewModel:Item'; + 'Pressed': 'trigger'; }; - Item: { - Item_Selection: 'enum:Coin|Gem'; + 'Item': { + 'Item_Selection': 'enum:Coin|Gem'; }; }; }>; diff --git a/example/assets/rive/style_fallback_fonts.riv.d.ts b/example/assets/rive/style_fallback_fonts.riv.d.ts index ecd23149..8e64cf29 100644 --- a/example/assets/rive/style_fallback_fonts.riv.d.ts +++ b/example/assets/rive/style_fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/viewmodelproperty.riv.d.ts b/example/assets/rive/viewmodelproperty.riv.d.ts index 949846e8..744ad485 100644 --- a/example/assets/rive/viewmodelproperty.riv.d.ts +++ b/example/assets/rive/viewmodelproperty.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - root: { - vm2: 'viewModel:vm'; - vm1: 'viewModel:vm'; + 'root': { + 'vm2': 'viewModel:vm'; + 'vm1': 'viewModel:vm'; }; - vm: { - name: 'string'; + 'vm': { + 'name': 'string'; }; }; }>; diff --git a/example/assets/rive/vm_value_change_test.riv.d.ts b/example/assets/rive/vm_value_change_test.riv.d.ts index d092fc1f..674ed043 100644 --- a/example/assets/rive/vm_value_change_test.riv.d.ts +++ b/example/assets/rive/vm_value_change_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - Artboard: 'State Machine 1'; + 'Artboard': 'State Machine 1'; }; viewModels: { - TextModel: { - trigger: 'trigger'; - textValue: 'string'; + 'TextModel': { + 'trigger': 'trigger'; + 'textValue': 'string'; }; }; }>; From 035a1ef573799b9e273b75f5d8c3b9e689700db4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:50:28 +0200 Subject: [PATCH 15/24] fix: exclude .riv.d.ts from lint, fix generator quoting to match prettier --- eslint.config.mjs | 1 + example/assets/rive/GradientBorder.riv.d.ts | 6 +- example/assets/rive/artboard_db_test.riv.d.ts | 14 +-- example/assets/rive/blinko.riv.d.ts | 104 +++++++++--------- example/assets/rive/bouncing_ball.riv.d.ts | 6 +- example/assets/rive/counter.riv.d.ts | 6 +- example/assets/rive/databinding.riv.d.ts | 26 ++--- .../assets/rive/databinding_images.riv.d.ts | 6 +- .../assets/rive/databinding_lists.riv.d.ts | 10 +- example/assets/rive/fallback_fonts.riv.d.ts | 2 +- example/assets/rive/font_fallback.riv.d.ts | 6 +- example/assets/rive/inputglow.riv.d.ts | 6 +- .../ios_android_layouts_demo_v01.riv.d.ts | 2 +- example/assets/rive/layout_test.riv.d.ts | 4 +- example/assets/rive/layouts_demo.riv.d.ts | 2 +- example/assets/rive/many_viewmodels.riv.d.ts | 10 +- example/assets/rive/movecircle.riv.d.ts | 6 +- .../assets/rive/nodefaultbouncing.riv.d.ts | 4 +- example/assets/rive/on_entry_test.riv.d.ts | 8 +- example/assets/rive/out_of_band.riv.d.ts | 2 +- example/assets/rive/quick_start.riv.d.ts | 14 +-- example/assets/rive/rewards.riv.d.ts | 52 ++++----- .../assets/rive/style_fallback_fonts.riv.d.ts | 2 +- .../assets/rive/viewmodelproperty.riv.d.ts | 12 +- .../assets/rive/vm_value_change_test.riv.d.ts | 8 +- scripts/rive-gen-types.ts | 21 +++- 26 files changed, 178 insertions(+), 162 deletions(-) diff --git a/eslint.config.mjs b/eslint.config.mjs index 7fc27c0d..55355c63 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -55,6 +55,7 @@ export default defineConfig([ 'lib/', '**/.expo/', '**/*.test-d.ts', + '**/*.riv.d.ts', ], }, ]); diff --git a/example/assets/rive/GradientBorder.riv.d.ts b/example/assets/rive/GradientBorder.riv.d.ts index 3fdc9e8e..a964f379 100644 --- a/example/assets/rive/GradientBorder.riv.d.ts +++ b/example/assets/rive/GradientBorder.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - 'Layout': 'State'; + Layout: 'State'; }; viewModels: { - 'ViewModel': { - 'isFocused': 'boolean'; + ViewModel: { + isFocused: 'boolean'; }; }; }>; diff --git a/example/assets/rive/artboard_db_test.riv.d.ts b/example/assets/rive/artboard_db_test.riv.d.ts index 33d2c567..6b8b0eb6 100644 --- a/example/assets/rive/artboard_db_test.riv.d.ts +++ b/example/assets/rive/artboard_db_test.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Main' | 'ArtboardGreen' | 'ArtboardBlue' | 'ArtboardRed'; defaultArtboard: 'Main'; stateMachines: { - 'Main': 'State Machine 1'; - 'ArtboardGreen': 'State Machine 1'; - 'ArtboardBlue': 'State Machine 1'; - 'ArtboardRed': 'State Machine 1'; + Main: 'State Machine 1'; + ArtboardGreen: 'State Machine 1'; + ArtboardBlue: 'State Machine 1'; + ArtboardRed: 'State Machine 1'; }; viewModels: { - 'MainViewModel': { - 'artboard_1': 'artboard'; - 'artboard_2': 'artboard'; + MainViewModel: { + artboard_1: 'artboard'; + artboard_2: 'artboard'; }; }; }>; diff --git a/example/assets/rive/blinko.riv.d.ts b/example/assets/rive/blinko.riv.d.ts index ccc3476b..8266f094 100644 --- a/example/assets/rive/blinko.riv.d.ts +++ b/example/assets/rive/blinko.riv.d.ts @@ -6,37 +6,37 @@ declare const asset: RiveAsset<{ artboards: 'Main' | 'StoreItem' | 'Token' | 'Indicator' | 'Puck' | 'StoreIcon' | 'Peg' | 'scoreBox'; defaultArtboard: 'Main'; stateMachines: { - 'Main': 'State Machine 1'; - 'StoreItem': 'State Machine 1'; - 'Token': 'State Machine 1'; - 'Indicator': 'State Machine 1'; - 'Puck': 'State Machine 1'; - 'StoreIcon': 'State Machine 1'; - 'Peg': 'State Machine 1'; - 'scoreBox': 'State Machine 1'; + Main: 'State Machine 1'; + StoreItem: 'State Machine 1'; + Token: 'State Machine 1'; + Indicator: 'State Machine 1'; + Puck: 'State Machine 1'; + StoreIcon: 'State Machine 1'; + Peg: 'State Machine 1'; + scoreBox: 'State Machine 1'; }; viewModels: { - 'IndicatorVM': { - 'purchased': 'boolean'; + IndicatorVM: { + purchased: 'boolean'; }; - 'StoreItemVM': { - 'tokenCount': 'number'; - 'height': 'number'; - 'itemHover': 'boolean'; - 'cost': 'number'; - 'description': 'string'; - 'id': 'string'; - 'itemType': 'string'; - 'maxPurchases': 'number'; - 'name': 'string'; - 'purchase': 'trigger'; - 'purchaseCount': 'number'; + StoreItemVM: { + tokenCount: 'number'; + height: 'number'; + itemHover: 'boolean'; + cost: 'number'; + description: 'string'; + id: 'string'; + itemType: 'string'; + maxPurchases: 'number'; + name: 'string'; + purchase: 'trigger'; + purchaseCount: 'number'; }; - 'storeIconVM': { - 'storeiconClick': 'trigger'; - 'iconHovered': 'boolean'; + storeIconVM: { + storeiconClick: 'trigger'; + iconHovered: 'boolean'; }; - 'storeVM': { + storeVM: { 'xbuttonClick': 'trigger'; 'xbuttonHover': 'boolean'; 'items': 'list'; @@ -52,37 +52,37 @@ declare const asset: RiveAsset<{ 'superMultiplierCost': 'number'; 'superMultiplierCount': 'number'; }; - 'TokenVM': { - 'spinToken': 'boolean'; + TokenVM: { + spinToken: 'boolean'; }; - 'pegVM': { - 'blink': 'trigger'; - 'multiplierValue': 'number'; - 'pegType': 'enum:normal|multiplier'; - 'pegBounced': 'trigger'; + pegVM: { + blink: 'trigger'; + multiplierValue: 'number'; + pegType: 'enum:normal|multiplier'; + pegBounced: 'trigger'; }; - 'gameLogicVM': { - 'turnTokens': 'number'; - 'turnScore': 'number'; - 'buttonLabel': 'string'; - 'message': 'string'; - 'startTurn': 'trigger'; - 'turnEnded': 'trigger'; - 'gameEnded': 'boolean'; - 'tokenCount': 'number'; - 'scoreTotal': 'number'; + gameLogicVM: { + turnTokens: 'number'; + turnScore: 'number'; + buttonLabel: 'string'; + message: 'string'; + startTurn: 'trigger'; + turnEnded: 'trigger'; + gameEnded: 'boolean'; + tokenCount: 'number'; + scoreTotal: 'number'; }; - 'scoreBox': { - 'Token': 'viewModel:TokenVM'; - 'slotType': 'enum:addToken|normal'; - 'landed': 'trigger'; - 'scoreValue': 'number'; + scoreBox: { + Token: 'viewModel:TokenVM'; + slotType: 'enum:addToken|normal'; + landed: 'trigger'; + scoreValue: 'number'; }; - 'PuckVM': { - 'puckBounce': 'trigger'; - 'puckRotation': 'number'; + PuckVM: { + puckBounce: 'trigger'; + puckRotation: 'number'; }; - 'main': { + main: { 'PuckVM': 'viewModel:PuckVM'; 'storeItemVM': 'viewModel:StoreItemVM'; 'storeIconVM': 'viewModel:storeIconVM'; diff --git a/example/assets/rive/bouncing_ball.riv.d.ts b/example/assets/rive/bouncing_ball.riv.d.ts index b6d2574d..10bc5f04 100644 --- a/example/assets/rive/bouncing_ball.riv.d.ts +++ b/example/assets/rive/bouncing_ball.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'vm': { - 'ypos': 'number'; + vm: { + ypos: 'number'; }; }; }>; diff --git a/example/assets/rive/counter.riv.d.ts b/example/assets/rive/counter.riv.d.ts index b1ba266a..244bbe14 100644 --- a/example/assets/rive/counter.riv.d.ts +++ b/example/assets/rive/counter.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel1': { - 'cnt': 'number'; + ViewModel1: { + cnt: 'number'; }; }; }>; diff --git a/example/assets/rive/databinding.riv.d.ts b/example/assets/rive/databinding.riv.d.ts index d8d93c3c..f0b630e5 100644 --- a/example/assets/rive/databinding.riv.d.ts +++ b/example/assets/rive/databinding.riv.d.ts @@ -6,22 +6,22 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'Person': { - 'pet': 'viewModel:Pet'; - 'jump': 'trigger'; - 'likes_popcorn': 'boolean'; - 'favourite_pet': 'enum:chipmunk|rat|frog|owl|cat|dog'; - 'favourite_color': 'color'; - 'age': 'number'; - 'website': 'string'; - 'name': 'string'; + Person: { + pet: 'viewModel:Pet'; + jump: 'trigger'; + likes_popcorn: 'boolean'; + favourite_pet: 'enum:chipmunk|rat|frog|owl|cat|dog'; + favourite_color: 'color'; + age: 'number'; + website: 'string'; + name: 'string'; }; - 'Pet': { - 'type': 'enum:chipmunk|rat|frog|owl|cat|dog'; - 'name': 'string'; + Pet: { + type: 'enum:chipmunk|rat|frog|owl|cat|dog'; + name: 'string'; }; }; }>; diff --git a/example/assets/rive/databinding_images.riv.d.ts b/example/assets/rive/databinding_images.riv.d.ts index 6d788405..b9d93374 100644 --- a/example/assets/rive/databinding_images.riv.d.ts +++ b/example/assets/rive/databinding_images.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'MyViewModel': { - 'bound_image': 'image'; + MyViewModel: { + bound_image: 'image'; }; }; }>; diff --git a/example/assets/rive/databinding_lists.riv.d.ts b/example/assets/rive/databinding_lists.riv.d.ts index 75795551..00334476 100644 --- a/example/assets/rive/databinding_lists.riv.d.ts +++ b/example/assets/rive/databinding_lists.riv.d.ts @@ -6,14 +6,14 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'Person': { - 'name': 'string'; + Person: { + name: 'string'; }; - 'DevRel': { - 'team': 'list'; + DevRel: { + team: 'list'; }; }; }>; diff --git a/example/assets/rive/fallback_fonts.riv.d.ts b/example/assets/rive/fallback_fonts.riv.d.ts index ab210750..60e8aa1d 100644 --- a/example/assets/rive/fallback_fonts.riv.d.ts +++ b/example/assets/rive/fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/font_fallback.riv.d.ts b/example/assets/rive/font_fallback.riv.d.ts index 367dd2ab..02bdda87 100644 --- a/example/assets/rive/font_fallback.riv.d.ts +++ b/example/assets/rive/font_fallback.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel': { - 'text': 'string'; + ViewModel: { + text: 'string'; }; }; }>; diff --git a/example/assets/rive/inputglow.riv.d.ts b/example/assets/rive/inputglow.riv.d.ts index 3b51f663..c1a84c21 100644 --- a/example/assets/rive/inputglow.riv.d.ts +++ b/example/assets/rive/inputglow.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Layout'; defaultArtboard: 'Layout'; stateMachines: { - 'Layout': 'State'; + Layout: 'State'; }; viewModels: { - 'ViewModel': { - 'isFocused': 'boolean'; + ViewModel: { + isFocused: 'boolean'; }; }; }>; diff --git a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts index 80be047c..549ba94c 100644 --- a/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts +++ b/example/assets/rive/ios_android_layouts_demo_v01.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + iOS_Android_Layouts_demo_v01: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/layout_test.riv.d.ts b/example/assets/rive/layout_test.riv.d.ts index 008fd913..25234ee9 100644 --- a/example/assets/rive/layout_test.riv.d.ts +++ b/example/assets/rive/layout_test.riv.d.ts @@ -6,10 +6,10 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel1': { + ViewModel1: { }; }; diff --git a/example/assets/rive/layouts_demo.riv.d.ts b/example/assets/rive/layouts_demo.riv.d.ts index a5587ce3..ac330ad0 100644 --- a/example/assets/rive/layouts_demo.riv.d.ts +++ b/example/assets/rive/layouts_demo.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'iOS_Android_Layouts_demo_v01'; defaultArtboard: 'iOS_Android_Layouts_demo_v01'; stateMachines: { - 'iOS_Android_Layouts_demo_v01': 'State Machine 1'; + iOS_Android_Layouts_demo_v01: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/many_viewmodels.riv.d.ts b/example/assets/rive/many_viewmodels.riv.d.ts index 2a890294..4e717058 100644 --- a/example/assets/rive/many_viewmodels.riv.d.ts +++ b/example/assets/rive/many_viewmodels.riv.d.ts @@ -6,13 +6,13 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'First': { - 'imageValue': 'image'; - 'colorValue': 'color'; - 'textValue': 'string'; + First: { + imageValue: 'image'; + colorValue: 'color'; + textValue: 'string'; }; }; }>; diff --git a/example/assets/rive/movecircle.riv.d.ts b/example/assets/rive/movecircle.riv.d.ts index f63db94b..229ae35c 100644 --- a/example/assets/rive/movecircle.riv.d.ts +++ b/example/assets/rive/movecircle.riv.d.ts @@ -6,11 +6,11 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'ViewModel': { - 'posY': 'number'; + ViewModel: { + posY: 'number'; }; }; }>; diff --git a/example/assets/rive/nodefaultbouncing.riv.d.ts b/example/assets/rive/nodefaultbouncing.riv.d.ts index 9a16de8e..60e32056 100644 --- a/example/assets/rive/nodefaultbouncing.riv.d.ts +++ b/example/assets/rive/nodefaultbouncing.riv.d.ts @@ -6,10 +6,10 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'VM1': { + VM1: { }; }; diff --git a/example/assets/rive/on_entry_test.riv.d.ts b/example/assets/rive/on_entry_test.riv.d.ts index 81e4ef07..56b087dc 100644 --- a/example/assets/rive/on_entry_test.riv.d.ts +++ b/example/assets/rive/on_entry_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'vm': { - 'input': 'number'; - 'inputOnEntry': 'number'; + vm: { + input: 'number'; + inputOnEntry: 'number'; }; }; }>; diff --git a/example/assets/rive/out_of_band.riv.d.ts b/example/assets/rive/out_of_band.riv.d.ts index 8b22e950..9546dc6a 100644 --- a/example/assets/rive/out_of_band.riv.d.ts +++ b/example/assets/rive/out_of_band.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/quick_start.riv.d.ts b/example/assets/rive/quick_start.riv.d.ts index b3abbe6b..4847c6a7 100644 --- a/example/assets/rive/quick_start.riv.d.ts +++ b/example/assets/rive/quick_start.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'health_bar_v01'; defaultArtboard: 'health_bar_v01'; stateMachines: { - 'health_bar_v01': 'State Machine 1'; + health_bar_v01: 'State Machine 1'; }; viewModels: { - 'health_bar_01': { - 'gameOver': 'trigger'; - 'hoverYes': 'boolean'; - 'hoverNo': 'boolean'; - 'healthColor': 'color'; - 'health': 'number'; + health_bar_01: { + gameOver: 'trigger'; + hoverYes: 'boolean'; + hoverNo: 'boolean'; + healthColor: 'color'; + health: 'number'; }; }; }>; diff --git a/example/assets/rive/rewards.riv.d.ts b/example/assets/rive/rewards.riv.d.ts index e34022fc..85ed68a4 100644 --- a/example/assets/rive/rewards.riv.d.ts +++ b/example/assets/rive/rewards.riv.d.ts @@ -15,36 +15,36 @@ declare const asset: RiveAsset<{ 'Item': 'State Machine 1'; }; viewModels: { - 'Item_Icon_Value': { - 'Icon_React': 'trigger'; - 'Property_Of_Item': 'viewModel:Item'; - 'Item_Value': 'number'; + Item_Icon_Value: { + Icon_React: 'trigger'; + Property_Of_Item: 'viewModel:Item'; + Item_Value: 'number'; }; - 'Energy_Bar': { - 'Bar_Color': 'color'; - 'Lives': 'number'; - 'Energy_Bar': 'number'; + Energy_Bar: { + Bar_Color: 'color'; + Lives: 'number'; + Energy_Bar: 'number'; }; - 'Rewards': { - 'Price_Value': 'number'; - 'Color': 'color'; - 'Height': 'number'; - 'With': 'number'; - 'Item_Selection': 'viewModel:Item'; - 'Item_Value_Icon': 'viewModel:Item_Icon_Value'; - 'Button': 'viewModel:Button'; - 'Coin': 'viewModel:Item_Icon_Value'; - 'Gem': 'viewModel:Item_Icon_Value'; - 'Energy_Bar': 'viewModel:Energy_Bar'; + Rewards: { + Price_Value: 'number'; + Color: 'color'; + Height: 'number'; + With: 'number'; + Item_Selection: 'viewModel:Item'; + Item_Value_Icon: 'viewModel:Item_Icon_Value'; + Button: 'viewModel:Button'; + Coin: 'viewModel:Item_Icon_Value'; + Gem: 'viewModel:Item_Icon_Value'; + Energy_Bar: 'viewModel:Energy_Bar'; }; - 'Button': { - 'State_1': 'string'; - 'Item_Text': 'string'; - 'Item': 'viewModel:Item'; - 'Pressed': 'trigger'; + Button: { + State_1: 'string'; + Item_Text: 'string'; + Item: 'viewModel:Item'; + Pressed: 'trigger'; }; - 'Item': { - 'Item_Selection': 'enum:Coin|Gem'; + Item: { + Item_Selection: 'enum:Coin|Gem'; }; }; }>; diff --git a/example/assets/rive/style_fallback_fonts.riv.d.ts b/example/assets/rive/style_fallback_fonts.riv.d.ts index 8e64cf29..ecd23149 100644 --- a/example/assets/rive/style_fallback_fonts.riv.d.ts +++ b/example/assets/rive/style_fallback_fonts.riv.d.ts @@ -6,7 +6,7 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; }>; export default asset; diff --git a/example/assets/rive/viewmodelproperty.riv.d.ts b/example/assets/rive/viewmodelproperty.riv.d.ts index 744ad485..949846e8 100644 --- a/example/assets/rive/viewmodelproperty.riv.d.ts +++ b/example/assets/rive/viewmodelproperty.riv.d.ts @@ -6,15 +6,15 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'root': { - 'vm2': 'viewModel:vm'; - 'vm1': 'viewModel:vm'; + root: { + vm2: 'viewModel:vm'; + vm1: 'viewModel:vm'; }; - 'vm': { - 'name': 'string'; + vm: { + name: 'string'; }; }; }>; diff --git a/example/assets/rive/vm_value_change_test.riv.d.ts b/example/assets/rive/vm_value_change_test.riv.d.ts index 674ed043..d092fc1f 100644 --- a/example/assets/rive/vm_value_change_test.riv.d.ts +++ b/example/assets/rive/vm_value_change_test.riv.d.ts @@ -6,12 +6,12 @@ declare const asset: RiveAsset<{ artboards: 'Artboard'; defaultArtboard: 'Artboard'; stateMachines: { - 'Artboard': 'State Machine 1'; + Artboard: 'State Machine 1'; }; viewModels: { - 'TextModel': { - 'trigger': 'trigger'; - 'textValue': 'string'; + TextModel: { + trigger: 'trigger'; + textValue: 'string'; }; }; }>; diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index bfb08b5b..3df1081b 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -48,22 +48,37 @@ function extractSchema(input: string): Schema { throw new Error('unreachable'); } +// With prettier quoteProps:"consistent", if any key in an object needs quotes, all get quotes. +const IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/; +const needsQuote = (s: string) => !IDENTIFIER_RE.test(s); +const quoteKey = (s: string, forceQuote: boolean) => + forceQuote || needsQuote(s) ? `'${s}'` : s; + function smRecord(stateMachines: Record): string { + const keys = Object.keys(stateMachines); + const force = keys.some(needsQuote); return Object.entries(stateMachines) .map(([ab, sms]) => { const union = sms.length ? sms.map((s) => `'${s}'`).join(' | ') : 'never'; - return ` '${ab}': ${union};`; + return ` ${quoteKey(ab, force)}: ${union};`; }) .join('\n'); } function vmRecord(viewModels: Record>): string { + const vmKeys = Object.keys(viewModels); + const forceVmKeys = vmKeys.some(needsQuote); return Object.entries(viewModels) .map(([vmName, props]) => { + const propKeys = Object.keys(props); + const forcePropKeys = propKeys.some(needsQuote); const propLines = Object.entries(props) - .map(([propName, propType]) => ` '${propName}': '${propType}';`) + .map( + ([propName, propType]) => + ` ${quoteKey(propName, forcePropKeys)}: '${propType}';` + ) .join('\n'); - return ` '${vmName}': {\n${propLines}\n };`; + return ` ${quoteKey(vmName, forceVmKeys)}: {\n${propLines}\n };`; }) .join('\n'); } From 2390f25e533771cad08c482518a7f6d550a4d654 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:56:48 +0200 Subject: [PATCH 16/24] chore: improve extractor error diagnostics --- scripts/rive-gen-types.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index 3df1081b..690e9fa5 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -36,10 +36,15 @@ function extractSchema(input: string): Schema { timeout: 30_000, }); if (result.error) throw result.error; + if (result.signal) throw new Error(`bun killed by signal ${result.signal}\n${result.stderr}`); if (result.status !== 0) throw new Error( result.stderr || `bun exited with code ${result.status}` ); + if (!result.stdout.trim()) + throw new Error( + `bun exited 0 but produced no output\nstderr: ${result.stderr || '(empty)'}` + ); return JSON.parse(result.stdout) as Schema; } catch (err) { if (attempt === 1) throw err; From bafe36a481282241ce62f7412be8b581ffd189a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 12:59:25 +0200 Subject: [PATCH 17/24] fix: wrap long throw to satisfy prettier --- scripts/rive-gen-types.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index 690e9fa5..0b1b1ea8 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -36,7 +36,10 @@ function extractSchema(input: string): Schema { timeout: 30_000, }); if (result.error) throw result.error; - if (result.signal) throw new Error(`bun killed by signal ${result.signal}\n${result.stderr}`); + if (result.signal) + throw new Error( + `bun killed by signal ${result.signal}\n${result.stderr}` + ); if (result.status !== 0) throw new Error( result.stderr || `bun exited with code ${result.status}` From 237c9fb6c5ec14584f9dad4062a079bf3c106ad5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 13:15:34 +0200 Subject: [PATCH 18/24] fix: handle null makeRenderImage on headless Linux, catch microtask errors --- scripts/rive-extract-schema.ts | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index 34a31597..756b69da 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -29,6 +29,18 @@ console.log = (...args: unknown[]) => console.warn = (...args: unknown[]) => process.stderr.write(args.join(' ') + '\n'); +// Catch errors from microtasks/unhandled rejections that would otherwise cause +// a silent exit with code 0 on some Bun versions (e.g. when img.la() throws in +// a queueMicrotask callback because WebGL is unavailable on Linux CI). +process.on('uncaughtException', (err) => { + process.stderr.write(`uncaughtException: ${err.stack ?? err.message}\n`); + process.exit(1); +}); +process.on('unhandledRejection', (reason) => { + process.stderr.write(`unhandledRejection: ${reason}\n`); + process.exit(1); +}); + if (!input) { process.stderr.write('Usage: bun rive-extract-schema.ts \n'); process.exit(1); @@ -50,12 +62,13 @@ async function main() { // Stub image loading: call la() (the "loaded" callback) immediately so // runtime.load() resolves without waiting for CDN asset fetches. + // Guard against null return when WebGL is unavailable (headless Linux). const origMRI = (runtime.renderFactory as any).makeRenderImage.bind( runtime.renderFactory ); (runtime.renderFactory as any).makeRenderImage = function () { const img = origMRI(); - queueMicrotask(() => img.la()); + if (img) queueMicrotask(() => img.la?.()); return img; }; From 1d5a58733b94b3d8cc4590bbe2c16521ec685b96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 13:46:50 +0200 Subject: [PATCH 19/24] fix: proxy stub for makeRenderImage when WebGL unavailable on headless Linux --- scripts/rive-extract-schema.ts | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index 756b69da..22e83071 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -60,17 +60,28 @@ async function main() { const bytes = await loadBytes(source); const runtime = await RuntimeLoader.awaitInstance(); - // Stub image loading: call la() (the "loaded" callback) immediately so - // runtime.load() resolves without waiting for CDN asset fetches. - // Guard against null return when WebGL is unavailable (headless Linux). - const origMRI = (runtime.renderFactory as any).makeRenderImage.bind( + // Stub makeRenderImage so runtime.load() resolves even without WebGL. + // On headless Linux, origMRI() returns null (no GPU), and passing null back + // causes the WASM to call process.exit(0) silently. Return a Proxy stub that + // no-ops all method calls and immediately fires the "loaded" callback (la). + const origMRI = (runtime.renderFactory as any).makeRenderImage?.bind( runtime.renderFactory ); - (runtime.renderFactory as any).makeRenderImage = function () { - const img = origMRI(); - if (img) queueMicrotask(() => img.la?.()); - return img; - }; + if (origMRI) { + (runtime.renderFactory as any).makeRenderImage = function () { + const img = origMRI(); + if (img) { + queueMicrotask(() => img.la?.()); + return img; + } + // No WebGL: proxy that no-ops all calls so the WASM doesn't crash + const stub: any = new Proxy(Object.create(null), { + get: (_t, _p) => () => {}, + }); + queueMicrotask(() => stub.la()); + return stub; + }; + } const riveFile = await runtime.load(bytes, undefined, false); From 93c1f37d2ba51266f752cb5750b49611be701b73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 13:59:09 +0200 Subject: [PATCH 20/24] fix: use CustomFileAssetLoader to skip embedded assets, avoids WebGL on headless Linux --- scripts/rive-extract-schema.ts | 31 ++++++++----------------------- 1 file changed, 8 insertions(+), 23 deletions(-) diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index 22e83071..bcec2e36 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -60,30 +60,15 @@ async function main() { const bytes = await loadBytes(source); const runtime = await RuntimeLoader.awaitInstance(); - // Stub makeRenderImage so runtime.load() resolves even without WebGL. - // On headless Linux, origMRI() returns null (no GPU), and passing null back - // causes the WASM to call process.exit(0) silently. Return a Proxy stub that - // no-ops all method calls and immediately fires the "loaded" callback (la). - const origMRI = (runtime.renderFactory as any).makeRenderImage?.bind( - runtime.renderFactory - ); - if (origMRI) { - (runtime.renderFactory as any).makeRenderImage = function () { - const img = origMRI(); - if (img) { - queueMicrotask(() => img.la?.()); - return img; - } - // No WebGL: proxy that no-ops all calls so the WASM doesn't crash - const stub: any = new Proxy(Object.create(null), { - get: (_t, _p) => () => {}, - }); - queueMicrotask(() => stub.la()); - return stub; - }; - } + // Use CustomFileAssetLoader to claim all embedded assets (images, fonts) as + // handled so the runtime never calls makeRenderImage. Without this, .riv files + // with embedded images cause the WASM to call process.exit(0) on headless Linux + // where WebGL is unavailable. We only need the schema (artboards/VMs), not images. + const assetLoader = new (runtime as any).CustomFileAssetLoader({ + loadContents: () => true, + }); - const riveFile = await runtime.load(bytes, undefined, false); + const riveFile = await runtime.load(bytes, assetLoader, false); const artboards: string[] = []; const stateMachines: Record = {}; From ba4798c2e3d1f8f790e80111aa1b35b1ff0a3a87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 14:19:59 +0200 Subject: [PATCH 21/24] fix(scripts): handle embedded images on headless Linux in rive-extract-schema Patch makeRenderImage to wrap img.decode so img.la() fires via queueMicrotask after the WASM K() returns (calling it synchronously resolves the Promise with null since H hasn't been assigned yet). Also pass actual embedded bytes through CustomFileAssetLoader so fonts and images are decoded, not just marked handled. --- scripts/rive-extract-schema.ts | 41 +++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) diff --git a/scripts/rive-extract-schema.ts b/scripts/rive-extract-schema.ts index bcec2e36..6e14816f 100644 --- a/scripts/rive-extract-schema.ts +++ b/scripts/rive-extract-schema.ts @@ -60,12 +60,43 @@ async function main() { const bytes = await loadBytes(source); const runtime = await RuntimeLoader.awaitInstance(); - // Use CustomFileAssetLoader to claim all embedded assets (images, fonts) as - // handled so the runtime never calls makeRenderImage. Without this, .riv files - // with embedded images cause the WASM to call process.exit(0) on headless Linux - // where WebGL is unavailable. We only need the schema (artboards/VMs), not images. + // On headless Linux (no WebGL) the WASM image-load counter (aa.total/aa.loaded) + // never reaches its target because image texture creation silently fails, so + // load() never resolves. We patch makeRenderImage to wrap img.decode so that + // img.la() is always called after decode — a safe no-op if WebGL already fired + // it, but unblocks the Promise when WebGL is absent. + const origMRI = (runtime.renderFactory as any).makeRenderImage.bind( + runtime.renderFactory + ); + (runtime.renderFactory as any).makeRenderImage = function () { + const img = origMRI(); + if ( + img && + typeof (img as any).la === 'function' && + typeof (img as any).decode === 'function' + ) { + const origDecode = (img as any).decode.bind(img); + (img as any).decode = function (imgBytes: Uint8Array) { + origDecode(imgBytes); // fires la() internally if WebGL succeeds + // Defer la() to a microtask so it fires *after* the WASM's K() returns and + // assigns H. Calling la() synchronously inside K() would resolve the Promise + // with H=null (K hasn't returned yet), producing an empty file. + queueMicrotask(() => (img as any).la()); + }; + } + return img; + }; + + // CustomFileAssetLoader handles embedded assets so the runtime resolves load(). + // For fonts: decode() loads font bytes (no WebGL needed). + // For images: decode() triggers our patched img.decode → img.la() unblocks. const assetLoader = new (runtime as any).CustomFileAssetLoader({ - loadContents: () => true, + loadContents: (asset: any, embeddedBytes: Uint8Array) => { + if (embeddedBytes?.length && asset?.decode) { + asset.decode(embeddedBytes); + } + return true; + }, }); const riveFile = await runtime.load(bytes, assetLoader, false); From 32bf37717381e18e84497128041b6dbc60d45c5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 14:42:23 +0200 Subject: [PATCH 22/24] fix(scripts): run WASM inline in rive-gen-types, drop spawnSync subprocess Spawning one bun process per .riv file via spawnSync was flaky under CI load: processes occasionally exited 0 with empty stdout due to resource contention. Now the WASM runtime is initialised once and all files are processed in the same process, eliminating the subprocess entirely. --- scripts/rive-gen-types.ts | 238 ++++++++++++++++++++++++++------------ 1 file changed, 162 insertions(+), 76 deletions(-) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index 0b1b1ea8..5bbecb0f 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -13,13 +13,24 @@ * const file = await RiveFileFactory.fromSource(gameRiv); // TypedRiveFile — T inferred */ -import { spawnSync } from 'child_process'; -import { writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'; +import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'; import { dirname, resolve, basename, extname } from 'path'; import { fileURLToPath } from 'url'; +import { RuntimeLoader } from '@rive-app/canvas'; const __dirname = dirname(fileURLToPath(import.meta.url)); -const extractorPath = resolve(__dirname, 'rive-extract-schema.ts'); + +// Browser shims required by the @rive-app/canvas WASM runtime. +(globalThis as any).document = { + createElement: () => ({ getContext: () => null }), +}; +(globalThis as any).Image = class {}; + +// Silence WASM warnings (e.g. "No WebGL support") so they don't pollute output. +console.log = (...args: unknown[]) => + process.stderr.write(args.join(' ') + '\n'); +console.warn = (...args: unknown[]) => + process.stderr.write(args.join(' ') + '\n'); interface Schema { artboards: string[]; @@ -28,32 +39,100 @@ interface Schema { viewModels: Record>; } -function extractSchema(input: string): Schema { - for (let attempt = 0; attempt < 2; attempt++) { - try { - const result = spawnSync('bun', [extractorPath, input], { - encoding: 'utf8', - timeout: 30_000, - }); - if (result.error) throw result.error; - if (result.signal) - throw new Error( - `bun killed by signal ${result.signal}\n${result.stderr}` - ); - if (result.status !== 0) - throw new Error( - result.stderr || `bun exited with code ${result.status}` - ); - if (!result.stdout.trim()) - throw new Error( - `bun exited 0 but produced no output\nstderr: ${result.stderr || '(empty)'}` - ); - return JSON.parse(result.stdout) as Schema; - } catch (err) { - if (attempt === 1) throw err; +let runtimeReady: Promise | null = null; + +async function getRuntime(): Promise { + if (!runtimeReady) { + runtimeReady = RuntimeLoader.awaitInstance().then((runtime) => { + // On headless Linux (no WebGL) the image-load counter (aa.total/aa.loaded) + // never resolves. Wrap img.decode to fire img.la() via queueMicrotask after + // K() returns so the Promise resolves with the actual file, not null. + const origMRI = (runtime.renderFactory as any).makeRenderImage.bind( + runtime.renderFactory + ); + (runtime.renderFactory as any).makeRenderImage = function () { + const img = origMRI(); + if ( + img && + typeof (img as any).la === 'function' && + typeof (img as any).decode === 'function' + ) { + const origDecode = (img as any).decode.bind(img); + (img as any).decode = function (imgBytes: Uint8Array) { + origDecode(imgBytes); + queueMicrotask(() => (img as any).la()); + }; + } + return img; + }; + return runtime; + }); + } + return runtimeReady; +} + +async function extractSchema(input: string): Promise { + const bytes = input.startsWith('http://') || input.startsWith('https://') + ? new Uint8Array(await (await fetch(input)).arrayBuffer()) + : new Uint8Array(readFileSync(input)); + + const runtime = await getRuntime(); + + const assetLoader = new (runtime as any).CustomFileAssetLoader({ + loadContents: (asset: any, embeddedBytes: Uint8Array) => { + if (embeddedBytes?.length && asset?.decode) { + asset.decode(embeddedBytes); + } + return true; + }, + }); + + const riveFile = await runtime.load(bytes, assetLoader, false); + + const artboards: string[] = []; + const stateMachines: Record = {}; + for (let i = 0; i < riveFile.artboardCount(); i++) { + const artboard = riveFile.artboardByIndex(i); + artboards.push(artboard.name); + const sms: string[] = []; + for (let j = 0; j < artboard.stateMachineCount(); j++) { + sms.push(artboard.stateMachineByIndex(j).name); + } + stateMachines[artboard.name] = sms; + } + + const viewModels: Record> = {}; + const vmCount = (riveFile as any).viewModelCount() as number; + for (let i = 0; i < vmCount; i++) { + const vm = (riveFile as any).viewModelByIndex(i); + const properties = vm.getProperties() as Array<{ name: string; type: string }>; + const inst = vm.instance?.() as any; + const props: Record = {}; + for (const p of properties) { + if (p.type === 'viewModel' && inst) { + try { + const nested = inst.viewModel?.(p.name); + const refName = nested?.getViewModelName?.(); + props[p.name] = refName ? `viewModel:${refName}` : 'viewModel'; + } catch { + props[p.name] = 'viewModel'; + } + } else if (p.type === 'enumType' && inst) { + try { + const ep = inst.enum?.(p.name); + const values: string[] = ep?.values ?? []; + props[p.name] = values.length > 0 ? `enum:${values.join('|')}` : 'enum'; + } catch { + props[p.name] = 'enum'; + } + } else { + props[p.name] = p.type; + } } + viewModels[vm.name] = props; } - throw new Error('unreachable'); + + return { artboards, defaultArtboard: artboards[0] ?? '', stateMachines, viewModels }; } // With prettier quoteProps:"consistent", if any key in an object needs quotes, all get quotes. @@ -133,7 +212,7 @@ ${schemaBody(schema)} `; } -function generate( +async function generate( input: string, outPath: string, mode: 'dts' | 'standalone', @@ -141,7 +220,7 @@ function generate( ) { let schema: Schema; try { - schema = extractSchema(input); + schema = await extractSchema(input); } catch (err) { process.stderr.write( `Failed to extract schema from ${input}: ${err instanceof Error ? err.message : String(err)}\n` @@ -179,58 +258,65 @@ function findRivFiles(dir: string): string[] { // --- CLI --- -// noUncheckedIndexedAccess: slice gives string[], index access gives string | undefined -const args: string[] = process.argv.slice(2); +async function main() { + // noUncheckedIndexedAccess: slice gives string[], index access gives string | undefined + const args: string[] = process.argv.slice(2); -if (args[0] === '--all') { - const dir: string | undefined = args[1]; - if (!dir) { - process.stderr.write('Usage: rive-gen-types --all \n'); - process.exit(1); - } - const files = findRivFiles(resolve(process.cwd(), dir)); - if (!files.length) { - process.stderr.write(`No .riv files found in ${dir}\n`); - process.exit(1); - } - for (const file of files) { - generate(file, `${file}.d.ts`, 'dts'); + if (args[0] === '--all') { + const dir: string | undefined = args[1]; + if (!dir) { + process.stderr.write('Usage: rive-gen-types --all \n'); + process.exit(1); + } + const files = findRivFiles(resolve(process.cwd(), dir)); + if (!files.length) { + process.stderr.write(`No .riv files found in ${dir}\n`); + process.exit(1); + } + for (const file of files) { + await generate(file, `${file}.d.ts`, 'dts'); + } + return; } - process.exit(0); -} - -if (!args.length || args[0]!.startsWith('--')) { - process.stderr.write( - 'Usage:\n' + - ' rive-gen-types # writes .riv.d.ts\n' + - ' rive-gen-types --out # standalone schema .ts\n' + - ' rive-gen-types --all # all .riv files in dir\n' - ); - process.exit(1); -} -const input = args[0]!; -const outIdx = args.indexOf('--out'); - -if (outIdx !== -1) { - // Standalone mode: generate a named schema type, not a .d.ts - const outPath = resolve(process.cwd(), args[outIdx + 1]!); - const baseName = basename(input, '.riv').replace(/[^a-zA-Z0-9]/g, '_'); - const nameIdx = args.indexOf('--name'); - const typeName = - nameIdx !== -1 - ? args[nameIdx + 1]! - : baseName.charAt(0).toUpperCase() + baseName.slice(1) + 'Schema'; - generate(input, outPath, 'standalone', typeName); -} else { - if (input.startsWith('http://') || input.startsWith('https://')) { + if (!args.length || args[0]!.startsWith('--')) { process.stderr.write( - `Error: URL inputs require --out to specify the output path.\n` + - ` Example: rive-gen-types ${input} --out ./assets/file.riv.d.ts\n` + 'Usage:\n' + + ' rive-gen-types # writes .riv.d.ts\n' + + ' rive-gen-types --out # standalone schema .ts\n' + + ' rive-gen-types --all # all .riv files in dir\n' ); process.exit(1); } - // Default: write .riv.d.ts next to the source file - const absInput = resolve(process.cwd(), input); - generate(input, `${absInput}.d.ts`, 'dts'); + + const input = args[0]!; + const outIdx = args.indexOf('--out'); + + if (outIdx !== -1) { + // Standalone mode: generate a named schema type, not a .d.ts + const outPath = resolve(process.cwd(), args[outIdx + 1]!); + const baseName = basename(input, '.riv').replace(/[^a-zA-Z0-9]/g, '_'); + const nameIdx = args.indexOf('--name'); + const typeName = + nameIdx !== -1 + ? args[nameIdx + 1]! + : baseName.charAt(0).toUpperCase() + baseName.slice(1) + 'Schema'; + await generate(input, outPath, 'standalone', typeName); + } else { + if (input.startsWith('http://') || input.startsWith('https://')) { + process.stderr.write( + `Error: URL inputs require --out to specify the output path.\n` + + ` Example: rive-gen-types ${input} --out ./assets/file.riv.d.ts\n` + ); + process.exit(1); + } + // Default: write .riv.d.ts next to the source file + const absInput = resolve(process.cwd(), input); + await generate(input, `${absInput}.d.ts`, 'dts'); + } } + +main().catch((err: Error) => { + process.stderr.write(err.message + '\n'); + process.exit(1); +}); From c84f2f7f4a24980b8bc772da7a6c399ac7d87a9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 15:03:01 +0200 Subject: [PATCH 23/24] chore: fix prettier formatting in rive-gen-types.ts --- scripts/rive-gen-types.ts | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index 5bbecb0f..c97b6e8d 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -13,7 +13,13 @@ * const file = await RiveFileFactory.fromSource(gameRiv); // TypedRiveFile — T inferred */ -import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'; +import { + readFileSync, + writeFileSync, + mkdirSync, + readdirSync, + statSync, +} from 'fs'; import { dirname, resolve, basename, extname } from 'path'; import { fileURLToPath } from 'url'; import { RuntimeLoader } from '@rive-app/canvas'; @@ -72,9 +78,10 @@ async function getRuntime(): Promise { } async function extractSchema(input: string): Promise { - const bytes = input.startsWith('http://') || input.startsWith('https://') - ? new Uint8Array(await (await fetch(input)).arrayBuffer()) - : new Uint8Array(readFileSync(input)); + const bytes = + input.startsWith('http://') || input.startsWith('https://') + ? new Uint8Array(await (await fetch(input)).arrayBuffer()) + : new Uint8Array(readFileSync(input)); const runtime = await getRuntime(); @@ -105,7 +112,10 @@ async function extractSchema(input: string): Promise { const vmCount = (riveFile as any).viewModelCount() as number; for (let i = 0; i < vmCount; i++) { const vm = (riveFile as any).viewModelByIndex(i); - const properties = vm.getProperties() as Array<{ name: string; type: string }>; + const properties = vm.getProperties() as Array<{ + name: string; + type: string; + }>; const inst = vm.instance?.() as any; const props: Record = {}; for (const p of properties) { @@ -121,7 +131,8 @@ async function extractSchema(input: string): Promise { try { const ep = inst.enum?.(p.name); const values: string[] = ep?.values ?? []; - props[p.name] = values.length > 0 ? `enum:${values.join('|')}` : 'enum'; + props[p.name] = + values.length > 0 ? `enum:${values.join('|')}` : 'enum'; } catch { props[p.name] = 'enum'; } @@ -132,7 +143,12 @@ async function extractSchema(input: string): Promise { viewModels[vm.name] = props; } - return { artboards, defaultArtboard: artboards[0] ?? '', stateMachines, viewModels }; + return { + artboards, + defaultArtboard: artboards[0] ?? '', + stateMachines, + viewModels, + }; } // With prettier quoteProps:"consistent", if any key in an object needs quotes, all get quotes. From a5120ced7260bdcbb7871481a239dab23aa2b1b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mikl=C3=B3s=20Fazekas?= Date: Mon, 15 Jun 2026 15:04:16 +0200 Subject: [PATCH 24/24] chore: remove unused __dirname from rive-gen-types.ts --- scripts/rive-gen-types.ts | 3 --- 1 file changed, 3 deletions(-) diff --git a/scripts/rive-gen-types.ts b/scripts/rive-gen-types.ts index c97b6e8d..156ce065 100644 --- a/scripts/rive-gen-types.ts +++ b/scripts/rive-gen-types.ts @@ -21,11 +21,8 @@ import { statSync, } from 'fs'; import { dirname, resolve, basename, extname } from 'path'; -import { fileURLToPath } from 'url'; import { RuntimeLoader } from '@rive-app/canvas'; -const __dirname = dirname(fileURLToPath(import.meta.url)); - // Browser shims required by the @rive-app/canvas WASM runtime. (globalThis as any).document = { createElement: () => ({ getContext: () => null }),