react-native-nobodywho 0.1.1 → 0.1.2

package/Nobodywho.podspec

@@ -43,10 +43,10 @@ Pod::Spec.new do |s|
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
   s.license      = package["license"]
-  s.authors      = package["author"]
+  s.authors      = package["author"] || { "NobodyWho" => "info@nobodywho.ooo" }
 
   s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/nobodywho-ooo/nobodywho", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/nobodywho-ooo/nobodywho.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}", "ios/generated/**/*.{h,m,mm}", "cpp/**/*.{hpp,cpp,c,h}", "generated/cpp/**/*.{hpp,cpp,c,h}"
   s.vendored_frameworks = framework_name

package/generated/ts/nobodywho.ts

@@ -693,108 +693,76 @@ const FfiConverterTypeMessage = (() => {
 
 
 
-// Error type: NobodyWhoError
 
-// Enum: NobodyWhoError
+// Flat error type: NobodyWhoError
 export enum NobodyWhoError_Tags {
     Error = "Error"
 }
 export const NobodyWhoError = (() => {
-    
-
-    type Error__interface = {
-        tag: NobodyWhoError_Tags.Error;
-        inner: Readonly<{message: string}>
-    };
-
-    
-    class Error_ extends UniffiError implements Error__interface {
+    class Error extends UniffiError {
         /**
          * @private
-         * This field is private and should not be used, use `tag` instead.
+         * This field is private and should not be used.
          */
-        readonly [uniffiTypeNameSymbol] = "NobodyWhoError";
-        readonly tag = NobodyWhoError_Tags.Error;
-        readonly inner: Readonly<{message: string}>;
-        constructor(inner: { message: string }) {
-            super("NobodyWhoError", "Error");
-            this.inner = Object.freeze(inner);
-        }
-
-        static new(inner: { message: string }): Error_ {
-            return new Error_(inner);
-        }
+        readonly [uniffiTypeNameSymbol]: string = "NobodyWhoError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 1;
 
-        static instanceOf(obj: any): obj is Error_ {
-            return obj.tag === NobodyWhoError_Tags.Error;
-        }
-        
+        readonly tag = NobodyWhoError_Tags.Error;
 
-        
-        static hasInner(obj: any): obj is Error_ {
-            return Error_.instanceOf(obj);
+        constructor(message: string) {
+            super("NobodyWhoError", "Error", message);
         }
 
-        static getInner(obj: Error_): Readonly<{message: string}> {
-            return obj.inner;
+        static instanceOf(e: any): e is Error {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1
+            );
         }
-
     }
 
-    function instanceOf(obj: any): obj is NobodyWhoError {
-        return obj[uniffiTypeNameSymbol] === "NobodyWhoError";
+    // Utility function which does not rely on instanceof.
+    function instanceOf(e: any): e is NobodyWhoError {
+        return (e as any)[uniffiTypeNameSymbol] === "NobodyWhoError";
     }
-
-    return Object.freeze({
+    return {
+        Error,
         instanceOf,
-  Error: Error_
-    });
-
+    };
 })();
 
+// Union type for NobodyWhoError error type.
 
 
 export type NobodyWhoError = InstanceType<
     typeof NobodyWhoError[keyof Omit<typeof NobodyWhoError, 'instanceOf'>]
 >;
 
-// FfiConverter for enum NobodyWhoError
 const FfiConverterTypeNobodyWhoError = (() => {
-    const ordinalConverter = FfiConverterInt32;
+    const intConverter = FfiConverterInt32;
     type TypeName = NobodyWhoError;
-    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
-            switch (ordinalConverter.read(from)) {
-                case 1: return new NobodyWhoError.Error({message: FfiConverterString.read(from) });
+            switch (intConverter.read(from)) {
+                case 1: return new NobodyWhoError.Error(FfiConverterString.read(from)
+                );
+            
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value: TypeName, into: RustBuffer): void {
-            switch (value.tag) {
-                case NobodyWhoError_Tags.Error: {
-                    ordinalConverter.write(1, into);
-                    const inner = value.inner;
-                    FfiConverterString.write(inner.message, into);
-                    return;
-                }
-                default:
-                    // Throwing from here means that NobodyWhoError_Tags hasn't matched an ordinal.
-                    throw new UniffiInternalError.UnexpectedEnumCase();
-            }
+            const obj = value as any;
+            const index = obj[variantOrdinalSymbol] as number;
+            intConverter.write(index, into);
         }
         allocationSize(value: TypeName): number {
-            switch (value.tag) {
-                case NobodyWhoError_Tags.Error: {
-                    const inner = value.inner;
-                    let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterString.allocationSize(inner.message);
-                    return size;
-                }
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
+            return intConverter.allocationSize(0);
         }
     }
-    return new FFIConverter();
+    return new FfiConverter();
 })();
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",