@rive-app/react-native 0.1.1-beta.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Rive
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,257 @@
+# @rive-app/react-native
+
+Rive React Native 2.0
+
+## Development Preview
+
+> **⚠️ Development Preview**: This package is currently in development preview. While it's functional and actively maintained, the API may change in future releases. We recommend testing thoroughly before using in production applications. We're actively gathering feedback to improve the library. Please share your thoughts and report any issues you encounter.
+
+## Requirements
+
+- **React Native**: 0.78 or later (0.79+ recommended for better Android error messages)
+- **Expo SDK**: 53 or later (for Expo users)
+- **iOS**: 15.1 or later
+- **Android**: SDK 24 (Android 7.0) or later
+- **Xcode**: 16.4 or later
+- **JDK**: 17 or later
+- **Nitro Modules**: 0.25.2 or later
+
+## Known Issues
+
+- Error messages on Android in React Native 0.78-0.79 may not be descriptive, this is a [known issue](https://github.com/mrousavy/nitro/issues/382) in React Native and is fixed in RN 0.80
+
+## Installation
+
+```sh
+npm install rive-app/rive-nitro-react-native react-native-nitro-modules
+```
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+
+## Usage
+
+```js
+import { Fit, RiveView, useRiveFile } from '@rive-app/react-native';
+
+function App() {
+  const { riveFile } = useRiveFile({
+    url: 'https://cdn.rive.app/animations/vehicles.riv',
+  });
+
+  if (!riveFile) {
+    return null;
+  }
+
+  return (
+    <RiveView
+      autoPlay={true}
+      fit={Fit.Contain}
+      file={riveFile}
+      onError={(error) => console.error('Rive error:', error.message)}
+      style={{ width: '100%', height: 400 }}
+    />
+  );
+}
+```
+
+## Native SDK Version Customization
+
+> **⚠️ Advanced Usage:** Customizing native SDK versions is intended for advanced users only. Using non-default versions may cause build-time errors, or compatibility issues. Always review and update custom versions when upgrading @rive-app/react-native.
+
+<details>
+
+<summary>Custom Native SDK Version instructions - <b>only use if you need it!</b></summary>
+
+By default, @rive-app/react-native uses specific versions of the Rive native SDKs defined in the library's `package.json` (`runtimeVersions.ios` and `runtimeVersions.android`). You can customize these versions if needed.
+
+### Vanilla React Native
+
+Add the appropriate properties to your configuration files:
+
+**iOS** - Add to `ios/Podfile.properties.json`:
+
+```json
+{
+  "RiveRuntimeIOSVersion": "6.13.0"
+}
+```
+
+**Android** - Add to `android/gradle.properties`:
+
+```properties
+Rive_RiveRuntimeAndroidVersion=10.6.0
+```
+
+### Expo
+
+Use an inline config plugin in your `app.config.ts`:
+
+```typescript
+import {
+  withPodfileProperties,
+  withGradleProperties,
+} from '@expo/config-plugins';
+
+export default {
+  expo: {
+    // ... other config
+    plugins: [
+      (config) => {
+        config = withPodfileProperties(config, (config) => {
+          config.modResults['RiveRuntimeIOSVersion'] = '6.13.0';
+          return config;
+        });
+
+        config = withGradleProperties(config, (config) => {
+          config.modResults.push({
+            type: 'property',
+            key: 'Rive_RiveRuntimeAndroidVersion',
+            value: '10.6.0',
+          });
+          return config;
+        });
+
+        return config;
+      },
+    ],
+  },
+};
+```
+</details>
+
+## Error Handling
+
+All Rive operations can be wrapped in try/catch blocks for error handling, for example, loading a file:
+
+```js
+try {
+  const riveFile = await RiveFileFactory.fromURL(
+    'https://cdn.rive.app/animations/vehicles.riv'
+  );
+  // Use the riveFile...
+} catch (error) {
+  // Handle any errors that occur during Rive file loading
+  console.error('Error loading Rive file:', error);
+}
+```
+
+### View-Based Errors
+
+The `RiveView` component provides an `onError` callback prop to handle errors that occur during view configuration or runtime operations:
+
+```js
+<RiveView
+  file={riveFile}
+  onError={(error) => {
+    // error.type contains the error type enum value
+    // error.message contains a descriptive error message
+    console.error(`Rive Error [${error.type}]: ${error.message}`);
+  }}
+/>
+```
+
+#### Error Types
+
+The following error types can occur during view operations:
+
+| Error Type                                     | Value | Description                                           |
+| ---------------------------------------------- | ----- | ----------------------------------------------------- |
+| `RiveErrorType.Unknown`                        | 0     | An unknown error occurred                             |
+| `RiveErrorType.FileNotFound`                   | 1     | The specified Rive file could not be found            |
+| `RiveErrorType.MalformedFile`                  | 2     | The Rive file is malformed or corrupted               |
+| `RiveErrorType.IncorrectArtboardName`          | 3     | The specified artboard name does not exist            |
+| `RiveErrorType.IncorrectStateMachineName`      | 4     | The specified state machine name does not exist       |
+| `RiveErrorType.ViewModelInstanceNotFound`      | 6     | The specified view model instance was not found       |
+| `RiveErrorType.IncorrectStateMachineInputName` | 8     | The specified state machine input name does not exist |
+
+You can use these error types to provide specific error handling:
+
+```js
+import { RiveView, RiveErrorType } from '@rive-app/react-native';
+
+<RiveView
+  file={riveFile}
+  artboardName="MainArtboard"
+  onError={(error) => {
+    switch (error.type) {
+      case RiveErrorType.IncorrectArtboardName:
+        console.error('Artboard not found:', error.message);
+        // Handle missing artboard (e.g., use default artboard)
+        break;
+      case RiveErrorType.IncorrectStateMachineName:
+        console.error('State machine not found:', error.message);
+        // Handle missing state machine
+        break;
+      case RiveErrorType.MalformedFile:
+        console.error('Corrupted file:', error.message);
+        // Handle corrupted file (e.g., show error UI)
+        break;
+      default:
+        console.error('Rive error:', error.message);
+    }
+  }}
+  style={{ width: '100%', height: 400 }}
+/>;
+```
+
+> **Note**: If no `onError` handler is provided, errors will be logged to the console by default.
+
+## Feature Support
+
+This section provides a comprehensive overview of feature availability in `@rive-app/react-native`, comparing it with the [previous Rive React Native runtime](https://github.com/rive-app/rive-react-native) and outlining the development roadmap.
+
+### Runtime Feature Comparison
+
+**Status Legend:** ✅ Supported | ⚠️ Partial | 🚧 In Development | ❌ Not Planned
+
+The following table compares feature availability with the [previous Rive React Native runtime](https://github.com/rive-app/rive-react-native).
+
+| Feature                           | Status | Description                                                      |
+| --------------------------------- | ------ | ---------------------------------------------------------------- |
+| Artboard selection                | ✅     | Specify artboard to render                                       |
+| State machine selection           | ✅     | Specify a state machine to play                                  |
+| View autoPlay & play/pause        | ✅     | Control view playback                                            |
+| Fit & Alignment                   | ✅     | Fit modes supported, alignment coming soon                       |
+| Layout & Responsiveness           | ✅     | Basic responsive layouts supported                               |
+| Data Binding                      | ✅     | Control data binding through runtime code                        |
+| Asset management                  | ✅     | Load assets out of band (referenced)                             |
+| State machine inputs (Deprecated) | ✅     | Get/Set (nested) state machine inputs (legacy, see data binding) |
+| Text Runs (Deprecated)            | ✅     | Update (nested) text runs (legacy, see data binding)             |
+| Rive Events (Deprecated)          | ✅     | Listen to Rive events                                            |
+| Rive Audio                        | ✅     | Rive audio playback supported                                    |
+| `useRive()` hook                  | ✅     | Convenient hook to access the Rive View ref after load           |
+| `useRiveFile()` hook              | ✅     | Convenient hook to load a Rive file                              |
+| `RiveView` error handling         | ✅     | Error handler for failed view operations                         |
+| `source` .riv file loading        | ✅     | Conveniently load .riv files from JS source                      |
+| Animation selection               | ❌     | Animation playback not planned, use state machines               |
+| Renderer options                  | ❌     | Single renderer option available (Rive)                          |
+
+> **Note**: Several features in the table above (state machine inputs, text runs, and events) represent legacy approaches to runtime control. We recommend using data binding instead, as it provides a more maintainable way to control your Rive graphics (both at edit time and runtime).
+
+### Roadmap
+
+**Status Legend:** ✅ Completed | 🚧 Planned |
+
+This section tracks new features and improvements planned for this runtime that were not available in the [previous Rive React Native runtime](https://github.com/rive-app/rive-react-native).
+
+| Feature                                                                                               | Status |
+| ----------------------------------------------------------------------------------------------------- | ------ |
+| [Reusable .riv File resources (preloading)](https://github.com/rive-app/rive-react-native/issues/260) | ✅     |
+| [Data Binding - Images](https://github.com/rive-app/rive-nitro-react-native/issues/9)                 | 🚧     |
+| [Data Binding - Artboards](https://github.com/rive-app/rive-nitro-react-native/issues/10)             | 🚧     |
+| [Data Binding - Lists](https://github.com/rive-app/rive-nitro-react-native/issues/11)                 | 🚧     |
+| [Data Binding - Value props](https://github.com/rive-app/rive-nitro-react-native/pull/24)             | 🚧     |
+| [Suspense](https://github.com/rive-app/rive-nitro-react-native/pull/19)                               | 🚧     |
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+

package/RNRive.podspec

@@ -0,0 +1,53 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+rive_ios_version = nil
+
+if ENV['RIVE_RUNTIME_IOS_VERSION']
+  rive_ios_version = ENV['RIVE_RUNTIME_IOS_VERSION']
+end
+
+if !rive_ios_version && defined?($RiveRuntimeIOSVersion)
+  rive_ios_version = $RiveRuntimeIOSVersion
+end
+
+if !rive_ios_version && defined?(Pod::Config) && Pod::Config.respond_to?(:instance)
+  podfile_properties_path = File.join(Pod::Config.instance.installation_root, 'Podfile.properties.json')
+  if File.exist?(podfile_properties_path)
+    podfile_properties = JSON.parse(File.read(podfile_properties_path)) rescue {}
+    rive_ios_version = podfile_properties['RiveRuntimeIOSVersion'] if podfile_properties['RiveRuntimeIOSVersion']
+  end
+end
+
+if !rive_ios_version && package['runtimeVersions'] && package['runtimeVersions']['ios']
+  rive_ios_version = package['runtimeVersions']['ios']
+end
+
+if !rive_ios_version
+  raise "Internal Error: Failed to determine Rive iOS SDK version. Please ensure package.json contains 'runtimeVersions.ios'"
+end
+
+Pod::UI.puts "@rive-app/react-native: Rive iOS SDK #{rive_ios_version}"
+
+Pod::Spec.new do |s|
+  s.name         = "RNRive"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/rive-app/rive-nitro-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.public_header_files = ['ios/RCTSwiftLog.h']
+  load 'nitrogen/generated/ios/RNRive+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency "RiveRuntime", rive_ios_version
+
+ install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(rive)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME rive)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/rive+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,155 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Rive_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/rive+autolinking.gradle'
+apply plugin: "com.facebook.react"
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "rive"
+  codegenJavaPackageName = "com.rive"
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Rive_" + name]).toInteger()
+}
+
+android {
+  namespace "com.rive"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters(*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = ["META-INF",
+                "META-INF/**",
+                "**/libc++_shared.so",
+                "**/libfbjni.so",
+                "**/libjsi.so",
+                "**/libfolly_json.so",
+                "**/libfolly_runtime.so",
+                "**/libglog.so",
+                "**/libhermes.so",
+                "**/libhermes-executor-debug.so",
+                "**/libhermes_executor.so",
+                "**/libreactnative.so",
+                "**/libreactnativejni.so",
+                "**/libturbomodulejsijni.so",
+                "**/libreact_nativemodule_core.so",
+                "**/libjscexecutor.so"]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += ["generated/java",
+                       "generated/jni"]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+def getRiveAndroidVersion() {
+  if (rootProject.ext.has('RiveRuntimeAndroidVersion')) {
+    return rootProject.ext.get('RiveRuntimeAndroidVersion')
+  }
+
+  if (project.hasProperty('Rive_RiveRuntimeAndroidVersion')) {
+    return project.property('Rive_RiveRuntimeAndroidVersion')
+  }
+
+  def packageJson = file("${projectDir}/../package.json")
+  if (packageJson.exists()) {
+    def json = new groovy.json.JsonSlurper().parseText(packageJson.text)
+    if (json.runtimeVersions?.android) {
+      return json.runtimeVersions.android
+    }
+  }
+
+  throw new GradleException("Failed to determine Rive Android SDK version. Please ensure package.json contains 'runtimeVersions.android'")
+}
+
+def riveAndroidVersion = getRiveAndroidVersion()
+println "@rive-app/react-native: Rive Android SDK ${riveAndroidVersion}"
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "app.rive:rive-android:${riveAndroidVersion}"
+  implementation "androidx.startup:startup-runtime:1.2.0"
+  implementation project(":react-native-nitro-modules")
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Rive_kotlinVersion=2.0.21
+Rive_minSdkVersion=24
+Rive_targetSdkVersion=34
+Rive_compileSdkVersion=35
+Rive_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+  <application>
+    <provider
+    android:name="androidx.startup.InitializationProvider"
+      android:authorities="${applicationId}.androidx-startup"
+      android:exported="false"
+      tools:node="merge">
+      <meta-data android:name="app.rive.runtime.kotlin.RiveInitializer"
+        android:value="androidx.startup" />
+    </provider>
+  </application>
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "riveOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::rive::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/rive/BaseHybridViewModelProperty.kt

@@ -0,0 +1,20 @@
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+
+@Keep
+@DoNotStrip
+interface BaseHybridViewModelProperty<T> {
+    val scope: CoroutineScope?
+    val job: Job?
+    val listeners: MutableList<(T) -> Unit>
+
+    fun ensureValueListenerJob(valueFlow: Flow<T>, drop: Int = 0)
+    fun onChanged(value: T)
+    fun removeListeners()
+    fun dispose()
+}

package/android/src/main/java/com/margelo/nitro/rive/BaseHybridViewModelPropertyImpl.kt

@@ -0,0 +1,50 @@
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.drop
+
+@Keep
+@DoNotStrip
+class BaseHybridViewModelPropertyImpl<T> : BaseHybridViewModelProperty<T> {
+    override var scope: CoroutineScope? = null
+    override var job: Job? = null
+    override val listeners = mutableListOf<(T) -> Unit>()
+
+  override fun ensureValueListenerJob(valueFlow: Flow<T>, drop: Int) {
+        if (scope == null) {
+            scope = CoroutineScope(Dispatchers.Default)
+        }
+        if (job == null) {
+            job = scope?.launch {
+                valueFlow.drop(drop).collect { value ->
+                    onChanged(value)
+                }
+            }
+        }
+    }
+
+    override fun onChanged(value: T) {
+        listeners.forEach { listener ->
+            listener(value)
+        }
+    }
+
+    override fun removeListeners() {
+        listeners.clear()
+        job?.cancel()
+        scope?.cancel()
+        job = null
+        scope = null
+    }
+
+    override fun dispose() {
+        removeListeners()
+    }
+}

package/android/src/main/java/com/margelo/nitro/rive/BytesDataLoader.kt

@@ -0,0 +1,9 @@
+package com.margelo.nitro.rive
+
+object BytesDataLoader : DataLoader {
+  override suspend fun load(source: DataSource): ByteArray {
+    val bytesSource = source as? DataSource.Bytes
+      ?: throw DataLoaderException.InvalidSource
+    return bytesSource.data
+  }
+}

package/android/src/main/java/com/margelo/nitro/rive/DataLoader.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.rive
+
+sealed class DataLoaderException(message: String) : Exception(message) {
+  object InvalidSource : DataLoaderException("Invalid data source type for this loader")
+  class InvalidURL(url: String) : DataLoaderException("Invalid URL: $url")
+  class HttpError(val statusCode: Int, url: String) :
+    DataLoaderException("HTTP error $statusCode for $url")
+  class ResourceNotFound(resource: String) : DataLoaderException("Resource not found: $resource")
+  class FileNotFound(path: String) : DataLoaderException("File not found: $path")
+  object NoContext : DataLoaderException("No application context available")
+}
+
+interface DataLoader {
+  suspend fun load(source: DataSource): ByteArray
+}

package/android/src/main/java/com/margelo/nitro/rive/DataSource.kt

@@ -0,0 +1,38 @@
+package com.margelo.nitro.rive
+
+import com.margelo.nitro.core.ArrayBuffer
+import java.net.URI
+
+sealed class DataSource {
+  data class Http(val url: String) : DataSource()
+  data class File(val path: String) : DataSource()
+  data class Resource(val name: String) : DataSource()
+  class Bytes(val data: ByteArray) : DataSource() {
+    companion object {
+      fun from(buffer: ArrayBuffer): Bytes {
+        val byteBuffer = buffer.getBuffer(false)
+        val byteArray = ByteArray(byteBuffer.remaining())
+        byteBuffer.get(byteArray)
+        return Bytes(byteArray)
+      }
+    }
+  }
+
+  companion object {
+    fun fromURL(url: String): DataSource {
+      val uri = URI(url)
+      return if (uri.scheme == "file") File(uri.path) else Http(url)
+    }
+
+    fun resource(nameWithExtension: String): Resource {
+      return Resource(nameWithExtension.substringBeforeLast("."))
+    }
+  }
+
+  fun createLoader(): DataLoader = when (this) {
+    is Http -> HTTPDataLoader
+    is File -> FileDataLoader
+    is Resource -> ResourceDataLoader
+    is Bytes -> BytesDataLoader
+  }
+}