jtlapp

// thanks to assistance from Martin Kavik and discord/rust @kpreid

use std::collections::HashMap;

pub type Value = i32;
pub type Result = std::result::Result<(), Error>;

#[derive(Debug, PartialEq, Eq)]
pub enum Error {
    DivisionByZero,

jtlapp

// Implements https://exercism.org/tracks/rust/exercises/forth. Errors on line 168.

use std::cell::RefCell;
use std::collections::HashMap;

pub type Value = i32;
pub type Result = std::result::Result<(), Error>;

#[derive(Debug, PartialEq, Eq)]
pub enum Error {

jtlapp

function exposeMainApi<T extends ElectronMainApi<T>>(mainApi: T): void {
  /* ... */
}

jtlapp

import type { MainApi1 } from '../backend/apis/main_api_1.ts';

async function doSomething() {
  const mainApi1 = await bindMainApi<MainApi1>("MainApi1");
  
  let result = await mainApi1.methodB();
  /* ... */
}

jtlapp

export async function bindMainApi<T extends ElectronMainApi<T>>(
  apiClassName: string
): Promise<MainApiBinding<T>> {
  // Use IPC to get a list of the API's methods from the main process.
  const methodNames = await requestApiMethods<T>(apiClassName);

  // boundApi will hold the binding, after we've added each method.
  const boundApi = {} as MainApiBinding<T>;

  // For each method name reported to be in the API...

jtlapp

import type { MainApi1 } from '../backend/apis/main_api_1.ts';
import type { MainApi2 } from '../backend/apis/main_api_2.ts';

async function bindMainApis() {
  return {
    mainApi1: await bindMainApi<MainApi1>("MainApi1"),
    mainApi2: await bindMainApi<MainApi2>("MainApi2"),
    /* ... */
  };
}

jtlapp

export type MainApiBinding<T> = {
  [K in PublicProperty<keyof T>]: T[K];
};

jtlapp

// This associates the name of each API with a list of the API's methods.
const exposedApis: Record<string, string[]> = {};

function exposeMainApi<T extends ElectronMainApi<T>>(mainApi: T): void {
  const apiClassName = mainApi.constructor.name;
  const methodNames: string[] = [];
  
  // For each property of mainApi...
  for (const methodName of getPropertyNames(mainApi)) {
    

jtlapp

export class MainApi1 implements ElectronMainApi<MainApi1> {

  methodA(arg1: string, arg2: number): Promise<void> {
    // code for methodA
  }
    
  methodB(): Promise<number> {
    // code for methodB
  }
}

jtlapp

export type PublicProperty<P> = P extends `_${string}`
  ? never
  : (P extends `#${string}` ? never : P);

export type ElectronMainApi<T> = {
  [K in PublicProperty<keyof T>]: (...args: any[]) => Promise<any>;
};