Library

import { Js65Worker, browserHostPort } from 'js65/worker-client';

const worker = new Worker('/js65-worker.js', {type: 'module'});
/** You only need to create this once and can reuse it multiple times */
export const js65 = new Js65Worker(browserHostPort(worker));

import { Worker } from 'node:worker_threads';
import { Js65Worker, nodeHostPort } from 'js65/worker-client';

const worker = new Worker(new URL(import.meta.resolve('js65/worker')));
const js65 = new Js65Worker(nodeHostPort(worker));

import { AsmEngine, sym, type PreloadedFiles } from 'js65/worker-client';
import type { CompileResult } from 'js65';
import { js65 } from './js65.ts';

// when you are ready to compile this, use `AsmEngine.build()` to create the inputs
// list that you can pass to `js65.compile()`
const asm = new AsmEngine();

function exampleModule() {
  // asm.module adds itself to the internal list of modules in the AsmEngine
  // so no need to return it
  const a = asm.module('main');
  // Use `.code` to pass in a whole block of asm directly
  a.code("; any code you want goes here", 'main.s');
  // Or if you have more compilcated needs, you can use the AsmModule's helper
  // methods to create asm directives and statements directly.
  a.segment('CODE');
  a.org(0x8000);
  a.label('itemTable');
  a.byte(items.map(item => item.id));
  // `sym` creates a named symbolic reference like a label or a constant
  a.word(sym('itemTable'));
}

// Below are some example helper functions 
export async function start(files: PreloadedFiles): Promise<void> {
  await js65.ready();
  // Sends all the preloaded file data to the worker. This only needs to be done once
  // and if the files change, you can use `fileChanged` below to update what changed.
  await js65.setFiles(files);
}

/** Call this when you need to update or delete a file on the worker */
export async function fileChanged(path: string, text: string | undefined): Promise<void> {
  await js65.applyFileDelta(text === undefined
      ? {upserts: new Map(), deletes: [path]}
      : {upserts: new Map([[path, text]]), deletes: []});
}

export async function build(baseRom: Uint8Array): Promise<CompileResult> {
  // The backend will try to load included files with these paths later, but you can also
  // just leave them out for a flat file structure as well. See the section on preloading
  // for more information.
  const INCLUDE_PATHS = ['/proj/src', '/proj/inc'];
  const BIN_INCLUDE_PATHS = ['/proj/assets'];
  return await js65.compile({
    request: {
      // `AsmEngine.build()` produces the list of actions for each compilation unit that we are building.
      // If you need to pass in source files, create a module with `AsmEngine.module()` and use `AsmModule.code()`
      inputs: asm.build(),
      options: {
        includePaths: INCLUDE_PATHS,
        binIncludePaths: BIN_INCLUDE_PATHS,
        generateDebugInfo: true,
      },
    },
    baseRom,
  });
}

const result = await build(editor.getValue(), items, baseRom);
if (!result.success) {
  for (const message of result.messages) {
    // `source` carries file/line/column, which is enough to place an editor marker.
    console.error(`${message.source?.file}:${message.source?.line}: ${message.message}`);
  }
} else {
  // The outputs contains a list of files, because it can contain the actual generated rom image,
  // the debug file, map files, and other outputs defined by the linker script.
  const rom = result.outputs.find(o => o.type === 'binary')!;
  const debug = result.outputs.find(o => o.type === 'debug');
  // Note that result.messages might still have `info`/`warning` level logs in it
  // that you might want to check!
  emulator.load(rom.data, debug?.data);
}

import { preloadDirectories, preloadPaths, type PreloadIo } from 'js65/worker-client';

/**
 * Here's an example fake in-memory file tree setup you can pass in to "preload"
 * for something like a browser IDE that already has all the files in `tree`
 * If you just want a flat file structure, or even try to fetch the data from some
 * remote listing, this can be hooked up to whatever file backing you need.
 */
function memoryIo(tree: Map<string, string | Uint8Array>): PreloadIo {
  return {
    // `fsListDir` form: bare names, with a trailing `/` on directories.
    listDir: (dir) => {
      const prefix = `${dir}/`;
      const names = new Set<string>();
      for (const path of tree.keys()) {
        if (!path.startsWith(prefix)) continue;
        const rest = path.slice(prefix.length);
        const slash = rest.indexOf('/');
        names.add(slash < 0 ? rest : `${rest.slice(0, slash)}/`);
      }
      return [...names];
    },
    readFile: (path) => tree.get(path),
  };
}

// The second param to preloadDirectories is the list of INCLUDE_DIR as if passed in
// through the -I flag on the command line.
const files = preloadDirectories(memoryIo(tree), ['/proj/inc', '/proj/assets']);
preloadPaths(memoryIo(tree), ['/proj/js65.cfg'], files);

import { preloadDirectories } from 'js65/worker-client';
import { nodePreloadIo } from 'js65/preload-node';

// nodePreloadIo wraps the filesystem 
await js65.setFiles(preloadDirectories(nodePreloadIo(), ['/proj/inc']));

let inFlight: number | undefined;

async function rebuild(request: Js65Request) {
  if (inFlight !== undefined) js65.cancel(inFlight);
  inFlight = js65.peekNextId();
  // A compile cancelled while it was running resolves with `success: false` and a
  // cancellation message. One cancelled before the worker ever picked it up rejects
  // instead, so a rebuild loop has to handle both.
  return await js65.compile({request}).catch(() => undefined);
}