camelCase

Author: pavelsavara

src/native/libs/System.Runtime.InteropServices.JavaScript.Native/interop/gc-handles.ts

@@ -6,8 +6,8 @@ import { InternalExchangeIndex } from "../types";
 import { dotnetUpdateInternals, dotnetUpdateInternalsSubscriber } from "./cross-module";
 import { bindJSImportST, invokeJSImportST, setModuleImports } from "./invoke-js";
 import { getAssemblyExports } from "./invoke-cs";
-import { initialize_marshalers_to_js } from "./marshal-to-js";
-import { initialize_marshalers_to_cs } from "./marshal-to-cs";
+import { initializeMarshalersToJs } from "./marshal-to-js";
+import { initializeMarshalersToCs } from "./marshal-to-cs";
 
 export function dotnetInitializeModule(internals: InternalExchange): void {
     if (!Array.isArray(internals)) throw new Error("Expected internals to be an array");
@@ -25,8 +25,8 @@ export function dotnetInitializeModule(internals: InternalExchange): void {
     });
     dotnetUpdateInternals(internals, dotnetUpdateInternalsSubscriber);
 
-    initialize_marshalers_to_js();
-    initialize_marshalers_to_cs();
+    initializeMarshalersToJs();
+    initializeMarshalersToCs();
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     function runtimeExportsToTable(map: RuntimeExports): RuntimeExportsTable {

src/native/libs/System.Runtime.InteropServices.JavaScript.Native/interop/index.ts

@@ -1,16 +1,16 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-import { assert_js_interop, bind_assembly_exports } from "./utils";
+import { assertJsInterop, bindAssemblyExports } from "./utils";
 
 export const exportsByAssembly: Map<string, any> = new Map();
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function getAssemblyExports(assemblyName: string): Promise<any> {
-    assert_js_interop();
+    assertJsInterop();
     const result = exportsByAssembly.get(assemblyName);
     if (!result) {
-        await bind_assembly_exports(assemblyName);
+        await bindAssemblyExports(assemblyName);
     }
 
     return exportsByAssembly.get(assemblyName) || {};

src/native/libs/System.Runtime.InteropServices.JavaScript.Native/interop/invoke-cs.ts

@@ -41,8 +41,8 @@ export const JSHandleNull: JSHandle = <JSHandle><any>0;
 export const GCHandleNull: GCHandle = <GCHandle><any>0;
 export const GCHandleInvalid: GCHandle = <GCHandle><any>-1;
 
-export type MarshalerToJs = (arg: JSMarshalerArgument, element_type?: MarshalerType, res_converter?: MarshalerToJs, arg1_converter?: MarshalerToCs, arg2_converter?: MarshalerToCs, arg3_converter?: MarshalerToCs) => any;
-export type MarshalerToCs = (arg: JSMarshalerArgument, value: any, element_type?: MarshalerType, res_converter?: MarshalerToCs, arg1_converter?: MarshalerToJs, arg2_converter?: MarshalerToJs, arg3_converter?: MarshalerToJs) => void;
+export type MarshalerToJs = (arg: JSMarshalerArgument, elementType?: MarshalerType, resConverter?: MarshalerToJs, arg1Converter?: MarshalerToCs, arg2Converter?: MarshalerToCs, arg3Converter?: MarshalerToCs) => any;
+export type MarshalerToCs = (arg: JSMarshalerArgument, value: any, elementType?: MarshalerType, resConverter?: MarshalerToCs, arg1Converter?: MarshalerToJs, arg2Converter?: MarshalerToJs, arg3Converter?: MarshalerToJs) => void;
 export type BoundMarshalerToJs = (args: JSMarshalerArguments) => any;
 export type BoundMarshalerToCs = (args: JSMarshalerArguments, value: any) => void;
 // please keep in sync with src\libraries\System.Runtime.InteropServices.JavaScript\src\System\Runtime\InteropServices\JavaScript\MarshalerType.cs
@@ -89,13 +89,13 @@ export type BindingClosure = {
     fn: Function,
     fqn: string,
     isDisposed: boolean,
-    args_count: number,
-    arg_marshalers: (BoundMarshalerToJs)[],
-    res_converter: BoundMarshalerToCs | undefined,
-    has_cleanup: boolean,
-    is_discard_no_wait: boolean,
-    is_async: boolean,
-    arg_cleanup: (Function | undefined)[]
+    argsCount: number,
+    argMarshalers: (BoundMarshalerToJs)[],
+    resConverter: BoundMarshalerToCs | undefined,
+    hasCleanup: boolean,
+    isDiscardNoWait: boolean,
+    isAsync: boolean,
+    argCleanup: (Function | undefined)[]
 }
 
 // TODO-WASM: drop mono prefixes, move the type

src/native/libs/System.Runtime.InteropServices.JavaScript.Native/interop/invoke-js.ts

@@ -7,7 +7,7 @@ export function fixupPointer(signature: any, shiftAmount: number): any {
     return ((signature as any) >>> shiftAmount) as any;
 }
 
-export function normalize_exception(ex: any) {
+export function normalizeException(ex: any) {
     let res = "unknown exception";
     if (ex) {
         res = ex.toString();
@@ -27,16 +27,16 @@ export function normalize_exception(ex: any) {
     return res;
 }
 
-export function is_runtime_running(): boolean {
+export function isRuntimeRunning(): boolean {
     // TODO-WASM
     return true;
 }
 
-export function assert_runtime_running(): void {
+export function assertRuntimeRunning(): void {
     // TODO-WASM
 }
 
-export function assert_js_interop(): void {
+export function assertJsInterop(): void {
     // TODO-WASM
 }
 
@@ -51,34 +51,34 @@ export function endMeasure(mark: number, fqn: string, additionalInfo: string): v
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function release_js_owned_object_by_gc_handle(gc_handle: GCHandle) {
+export function releaseJsOwnedObjectByGcHandle(gcHandle: GCHandle) {
     // TODO-WASM
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function get_managed_stack_trace(gc_handle: GCHandle): string {
+export function getManagedStackTrace(gcHandle: GCHandle): string {
     // TODO-WASM
     return "";
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function call_delegate(callback_gc_handle: GCHandle, arg1_js: any, arg2_js: any, arg3_js: any, res_converter?: MarshalerToJs, arg1_converter?: MarshalerToCs, arg2_converter?: MarshalerToCs, arg3_converter?: MarshalerToCs) {
+export function callDelegate(callbackGcHandle: GCHandle, arg1Js: any, arg2Js: any, arg3Js: any, resConverter?: MarshalerToJs, arg1Converter?: MarshalerToCs, arg2Converter?: MarshalerToCs, arg3Converter?: MarshalerToCs) {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function SystemInteropJS_ReleaseCSOwnedObject(js_handle: JSHandle) {
+export function SystemInteropJS_ReleaseCSOwnedObject(jsHandle: JSHandle) {
     // TODO-WASM
 }
 
-export function isThenable(js_obj: any): boolean {
+export function isThenable(jsObj: any): boolean {
     // When using an external Promise library like Bluebird the Promise.resolve may not be sufficient
     // to identify the object as a Promise.
-    return Promise.resolve(js_obj) === js_obj ||
-        ((typeof js_obj === "object" || typeof js_obj === "function") && typeof js_obj.then === "function");
+    return Promise.resolve(jsObj) === jsObj ||
+        ((typeof jsObj === "object" || typeof jsObj === "function") && typeof jsObj.then === "function");
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function bind_assembly_exports(assemblyName: string): Promise<void> {
+export function bindAssemblyExports(assemblyName: string): Promise<void> {
     // TODO-WASM
     return Promise.resolve();
 }

src/native/libs/System.Runtime.InteropServices.JavaScript.Native/interop/marshal-to-cs.ts

@@ -3,24 +3,24 @@
 
 import { WeakRefInternal } from "./types";
 
-export const _use_weak_ref = typeof globalThis.WeakRef === "function";
+export const useWeakRef = typeof globalThis.WeakRef === "function";
 
-export function create_weak_ref<T extends object>(js_obj: T): WeakRefInternal<T> {
-    if (_use_weak_ref) {
-        return new WeakRef(js_obj);
+export function createWeakRef<T extends object>(jsObj: T): WeakRefInternal<T> {
+    if (useWeakRef) {
+        return new WeakRef(jsObj);
     } else {
         // this is trivial WeakRef replacement, which holds strong refrence, instead of weak one, when the browser doesn't support it
-        return create_strong_ref(js_obj);
+        return createStrongRef(jsObj);
     }
 }
 
-export function create_strong_ref<T extends object>(js_obj: T): WeakRefInternal<T> {
+export function createStrongRef<T extends object>(jsObj: T): WeakRefInternal<T> {
     return <any>{
         deref: () => {
-            return js_obj;
+            return jsObj;
         },
         dispose: () => {
-            js_obj = null!;
+            jsObj = null!;
         }
     };
 }