Import Functions

Import Synthetic Modules

To import functions from another plugin, use Plugify's import system to load the synthetic module for the target plugin.

import { Plugin, Vector2, Vector3, Vector4, Matrix4x4 } from 'plugify';
import * as master from ':plugin_from_another_language';

• plugify: The core Plugify module, providing utility classes like Vector2, Vector3, etc.
• plugin_from_another_language: The synthetic module for the target plugin. Replace this with the name of the plugin you want to import functions from.

Call the Imported Functions

Once the synthetic module is imported, you can call its functions directly.

Example 1: Calling a Simple Function

export const func = () => {
    master.ParamCallback(
        111, 
        2.2, 
        5.1234, 
        new Vector4(-125.1, -225.2, -325.3, -425.4), 
        [60000000, -700000000, 80000000000], 
        'D', 
        'pink metal', 
        'Y', 
        -100
    );
};

• ParamCallback: This is an example function exported by the target plugin. Replace it with the actual function name.
• Parameters: Pass the required parameters as defined by the function signature.

Example 2: Calling a Function with a Callback Parameter

If the imported function requires a callback as a parameter, you can define the callback in JavaScript and pass it to the function. Here’s an example:

export class CallbackHolder {
    static mockFunc(u32, v3, u_vec) {
        // Modify the parameters (passed by reference)
        u32 = 42;
        v3 = new Vector3(1.0, 2.0, 3.0);
        u_vec = [1, 2, 3];
        // Return the modified values in an array
        return [null, u32, v3, u_vec];
    }
}

export const func_call = () => {
    const result = master.CallFuncCallback(CallbackHolder.mockFunc);
    return result;
};

• CallFuncCallback: This is an example function that accepts a callback as a parameter.
• mockFunc: This is the callback function defined in JavaScript. It modifies the parameters passed by reference and returns them in an array.
• Return Values: The callback function returns null (for the void return type) and the modified parameters.

Using the Online Generator:

Visit plugify-gen tool to generate type files through a user-friendly web interface. Simply upload your plugin manifest file (.pplugin) and select JavaScript/TypeScript as the target language to generate the corresponding .d.ts type definition file.

Using the Command-Line Tool:

You can also download and use the generator tool locally from the plugify-gen repository.

Example usage:

plugify-gen -manifest ./plugins/MyPlugin/MyPlugin.pplugin -output ./types/ -lang v8

Generated Type File:

• The script will generate a type file (e.g., MyPlugin.d.ts) in the specified output folder.
• Example type file content:
  MyPlugin.d.ts

  import { Vector2, Vector3, Vector4, Matrix4x4 } from 'plugify';
  
  declare module ':cross_call_master' {
      export function ParamCallback(
          a: number, 
          b: number, 
          c: number, 
          d: Vector4, 
          e: number[], 
          f: string, 
          g: string, 
          h: string, 
          k: number
      ): void;
  
      export type Func = (u32: number, vec3: Vector3, vecU32: number[]) => [void,number,Vector3,number[]];
      export function CallFuncCallback(callback: Func): string;
  }
  

Using Type Files in Your IDE:

• Place the generated type file (.d.ts) in your project directory (but not in the plugins folder).
• IDEs like VSCode will use the type file to provide type hints and autocompletion.

VSCode Support:

• VSCode automatically detects type files in your project. Ensure the types folder (or the folder containing your .d.ts files) is included in your tsconfig.json or jsconfig.json file.
• Example tsconfig.json configuration:
  {
      "compilerOptions": {
          "typeRoots": ["./types"]
      }
  }