scripts.js

import fs from 'fs';
import path from 'path';
import luaparse from 'luaparse';
import zlib from 'node:zlib';
import { Buffer } from 'node:buffer';

function parseLuaSource(source, options = {}) {
    const parseOptions = Object.assign(
        { comments: false, scope: false, locations: true, ranges: false, luaVersion: '5.3' },
        options
    );
    return luaparse.parse(source, parseOptions);
}

function walkAst(node, visitor) {
    const seen = new WeakSet();

    function _walk(n) {
        if (!n || typeof n !== 'object') return;
        if (seen.has(n)) return;
        seen.add(n);

        visitor(n);

        for (const key of Object.keys(n)) {
            const v = n[key];
            if (Array.isArray(v)) {
                for (const item of v) _walk(item);
            } else if (v && typeof v === 'object') {
                _walk(v);
            }
        }
    }

    _walk(node);
}

function extractRequireModuleNamesFromAst(ast) {
    const modules = new Set();

    walkAst(ast, (node) => {
        if (node.type === 'CallExpression') {
            const base = node.base;
            const args = node.arguments || node.arguments;
            if (base && base.type === 'Identifier' && base.name === 'require') {
                const first = Array.isArray(args) && args[0];
                if (first && first.type === 'StringLiteral') {
                    modules.add(first.raw.slice(1, -1));
                }
            }
        }

        if (node.type === 'CallStatement' && node.expression && node.expression.type === 'CallExpression') {
            const expr = node.expression;
            const base = expr.base;
            const args = expr.arguments;
            if (base && base.type === 'Identifier' && base.name === 'require') {
                const first = Array.isArray(args) && args[0];
                if (first && first.type === 'StringLiteral') {
                    modules.add(first.raw.slice(1, -1));
                }
            }
        }
    });

    return Array.from(modules);
}

function resolveModuleToFile(moduleName, fromFile, projectRoot = undefined) {
    const fromDir = path.dirname(fromFile);

    function firstExisting(candidates) {
        for (const p of candidates) {
            try {
                const stat = fs.statSync(p);
                if (stat && stat.isFile()) return p;
            } catch (e) {
            }
        }
        return null;
    }

    if (moduleName.startsWith('./') || moduleName.startsWith('../') || moduleName.startsWith('/')) {
        const candidate = path.resolve(fromDir, moduleName);
        const candidates = [
            candidate,
            candidate.endsWith('.lua') ? null : `${candidate}.lua`,
            candidate.endsWith('.lua') ? null : path.join(candidate, 'init.lua'),
        ].filter(Boolean);
        return firstExisting(candidates);
    }

    const dotPath = moduleName.includes('.') ? moduleName.split('.').join(path.sep) : moduleName;
    const slashPath = moduleName.includes('/') ? moduleName : dotPath;

    const tryList = [];

    tryList.push(path.resolve(fromDir, `${slashPath}.lua`));
    tryList.push(path.resolve(fromDir, slashPath, 'init.lua'));
    tryList.push(path.resolve(fromDir, slashPath));

    if (projectRoot) {
        tryList.push(path.resolve(projectRoot, `${slashPath}.lua`));
        tryList.push(path.resolve(projectRoot, slashPath, 'init.lua'));
        tryList.push(path.resolve(projectRoot, slashPath));
    }

    tryList.push(path.resolve(fromDir, moduleName));
    if (projectRoot) tryList.push(path.resolve(projectRoot, moduleName));

    return firstExisting(tryList);
}

function collectUsedFiles(entryFile, projectRoot = process.cwd(), opts = {}) {
    const parseOptions = opts.parseOptions || {};
    const resolveMissing = opts.resolveMissing ?? false;

    const entryAbs = path.resolve(entryFile);
    const visited = new Set();
    const usedFiles = new Set();
    const missing = new Set();
    const dependencyMap = new Map();

    const stack = [entryAbs];

    while (stack.length > 0) {
        const file = stack.pop();
        if (visited.has(file)) continue;
        visited.add(file);

        let src;
        try {
            src = fs.readFileSync(file, 'utf8');
        } catch (e) {
            missing.add(file);
            continue;
        }

        usedFiles.add(file);

        let ast;
        try {
            ast = parseLuaSource(src, parseOptions);
        } catch (e) {
            dependencyMap.set(file, [`<parse-error>: ${e.message}`]);
            continue;
        }

        const modules = extractRequireModuleNamesFromAst(ast);
        dependencyMap.set(file, []);

        for (const modName of modules) {
            const resolved = resolveModuleToFile(modName, file, projectRoot);
            if (resolved) {
                dependencyMap.get(file).push(resolved);
                if (!visited.has(resolved)) stack.push(resolved);
            } else {
                dependencyMap.get(file).push(modName);
                missing.add(modName);
                if (resolveMissing) {
                }
            }
        }
    }

    return { usedFiles, missing, dependencyMap };
}

const MAGIC = Buffer.from([0xC4, 0x19, 0x7B, 0xFA]);
const PREFIX = "GLOBED_SCRIPT";

let encodeScript = ({
  prefix = PREFIX,
  filename = '',
  content = '',
  isMain = false,
  signature = null,
  tail = null,
} = {}) => {
  const prefixBytes = Buffer.from(prefix, 'utf8');
  const headerStart = Buffer.concat([prefixBytes, Buffer.from([0x00]), MAGIC]);

  const parts = [];

  parts.push(Buffer.from([isMain ? 1 : 0]));

  const filenameBuf = Buffer.from(filename, 'utf8');
  if (filenameBuf.length > 0xFFFF) {
    throw new RangeError(`Filename is too long: ${filenameBuf.length} bytes (max 65535).`);
  }
  const filenameSizeBuf = Buffer.alloc(2);
  filenameSizeBuf.writeUInt16LE(filenameBuf.length, 0);
  parts.push(filenameSizeBuf, filenameBuf);

  const contentBuf = Buffer.from(content, 'utf8');
  if (contentBuf.length > 0xFFFFFFFF) {
    throw new RangeError(`Content is too long: ${contentBuf.length} bytes (max 2^32-1).`);
  }
  const contentSizeBuf = Buffer.alloc(4);
  contentSizeBuf.writeUInt32LE(contentBuf.length, 0);
  parts.push(contentSizeBuf, contentBuf);

  if (signature != null) {
    if (!Buffer.isBuffer(signature) || signature.length !== 32) {
      throw new TypeError('signature must be a Buffer of length 32 if provided.');
    }
    parts.push(Buffer.from([1]), signature);
  } else {
    parts.push(Buffer.from([0]));
  }

  if (tail != null) {
    if (!Buffer.isBuffer(tail)) throw new TypeError('tail must be a Buffer if provided.');
    parts.push(tail);
  }

  const data = Buffer.concat(parts);
  const dataSizeBuf = Buffer.alloc(4);
  dataSizeBuf.writeUInt32LE(data.length, 0);

  const compressed = zlib.zstdCompressSync(data, {
    params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 }
  });

  return Buffer.concat([headerStart, dataSizeBuf, compressed]);
}

function normalizeScriptFilename(filePath, projectRoot) {
    const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, '/');
    return relativePath || path.basename(filePath);
}

function createScriptObjects(entryAbs, tree, projectRoot, opts = {}) {
    const scripts = [];
    const usedFiles = Array.from(tree.usedFiles);

    for (const filePath of usedFiles) {
        const filename = normalizeScriptFilename(filePath, projectRoot);
        const content = fs.readFileSync(filePath, 'utf8');
        const encoded = encodeScript({ content: 'local exports = require(".exports.lua")\n'+content, filename, isMain: filePath === entryAbs });
        const script = encoded.toString('base64')
            .replace(/\+/g, '-')
            .replace(/\//g, '_');

        if (opts.addObjects !== false) {
            object({
                OBJ_ID: 914,
                Y: -10000,
                TEXT: script
            }).add();
        }

        scripts.push({
            filePath,
            filename,
            content,
            base64: script,
            isMain: filePath === entryAbs,
        });
    }

    return scripts;
}

function project(entryFile, opts = {}) {
    const entryAbs = path.resolve(entryFile);
    const projectRoot = opts.projectRoot ? path.resolve(opts.projectRoot) : path.dirname(entryAbs);

    const tree = collectUsedFiles(entryAbs, projectRoot, opts);
    const scripts = createScriptObjects(entryAbs, tree, projectRoot, opts);

    return {
        entry: entryAbs,
        projectRoot,
        usedFiles: Array.from(tree.usedFiles),
        missing: Array.from(tree.missing),
        dependencyMap: tree.dependencyMap,
        scripts,
    };
}

export { project, encodeScript }