323 lines
10 KiB
JavaScript
Executable File
323 lines
10 KiB
JavaScript
Executable File
const os = require('os');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const tmp = require('tmp-file');
|
|
const exec = require('./exec');
|
|
const through = require('through2');
|
|
const Sdk = require('./sdk');
|
|
const Vinyl = require('vinyl');
|
|
const PluginError = require('plugin-error');
|
|
const colors = require('ansi-colors');
|
|
const log = require('fancy-log');
|
|
const vfs = require('vinyl-fs');
|
|
const rmdir = require('rmdir');
|
|
|
|
|
|
class Haxe extends Sdk {
|
|
|
|
getBin(name) {
|
|
if (Sdk.System.isWindows) {
|
|
return `${this.binPath}/${name}.exe`;
|
|
} else if (Sdk.System.isLinux) {
|
|
const binPath = `${this.binPath}/${name}`;
|
|
fs.chmodSync(binPath, 0o755);
|
|
return binPath;
|
|
}
|
|
throw `Unsupported OS: ${os.type()}`;
|
|
}
|
|
|
|
get binPath() {
|
|
return `${this.path}`;
|
|
}
|
|
|
|
get haxeBin() {
|
|
return this.getBin('haxe');
|
|
}
|
|
|
|
get haxelibBin() {
|
|
return this.getBin('haxelib');
|
|
}
|
|
|
|
constructor(version) {
|
|
super(Haxe.ID, version || Haxe.VERSION);
|
|
}
|
|
|
|
get prepared() {
|
|
try {
|
|
return fs.existsSync(this.haxeBin);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
activate() {
|
|
process.env.HAXE_VERSION = this.version;
|
|
process.env.HAXE_STD_PATH = `${this.binPath}/std`;
|
|
process.env.HAXE_HOME = this.binPath;
|
|
process.env.PATH = `${process.env.PATH}:${this.binPath}`;
|
|
}
|
|
|
|
prepare() {
|
|
return super.prepare().then(() => this.activate());
|
|
}
|
|
|
|
get link() {
|
|
if (Sdk.System.isWindows) {
|
|
return `https://github.com/HaxeFoundation/haxe/releases/download/${this.version}/haxe-${this.version}-win.zip`;
|
|
} else if (Sdk.System.isLinux) {
|
|
let arch = Sdk.System.archInt;
|
|
return `https://github.com/HaxeFoundation/haxe/releases/download/${this.version}/haxe-${this.version}-linux${arch}.tar.gz`;
|
|
}
|
|
}
|
|
|
|
haxe(args) {
|
|
return exec('.', [this.haxeBin].concat(args).join(' '));
|
|
}
|
|
|
|
haxelib(args) {
|
|
const haxelibBin = this.haxelibBin;
|
|
//return exec(this.binPath, [path.basename(haxelibBin)].concat(args).join(' '));
|
|
return exec('.', [haxelibBin].concat(args).join(' '));
|
|
}
|
|
|
|
install(packages) {
|
|
let promise = this.haxelib(['setup', `${this.path}/lib`]);
|
|
const next = (args) => () => {
|
|
log(this.tag, colors.cyan('haxelib', 'install'), colors.magenta(args[1]));
|
|
return this.haxelib(args);
|
|
};
|
|
|
|
if (!Array.isArray(packages)) {
|
|
packages = Object.entries(packages).map(([k, v]) => ({name: k, version: v}));
|
|
}
|
|
|
|
for (let pack of packages) {
|
|
const args = [];
|
|
let version = null;
|
|
if (typeof pack === 'string') {
|
|
args.push('install', pack);
|
|
} else if (typeof pack === 'object') {
|
|
version = pack.version;
|
|
if (version.substr(0, 3) === 'git') {
|
|
pack.git = version;
|
|
version = null;
|
|
}
|
|
if (pack.git) {
|
|
args.push('git', pack.name, pack.git);
|
|
if (pack.branch) args.push(pack.branch);
|
|
} else {
|
|
args.push('install', pack.name);
|
|
if (version) args.push(version);
|
|
}
|
|
args.push('--always');
|
|
}
|
|
let path = `${this.path}/lib/${args[1]}`;
|
|
if (version) {
|
|
path += `/${version.replace(/\./g, ',')}`;
|
|
} else if (pack.git) {
|
|
path += '/git';
|
|
}
|
|
if (!fs.existsSync(path)) {
|
|
promise = promise.then(next(args));
|
|
}
|
|
}
|
|
return promise;
|
|
}
|
|
|
|
upgrade() {
|
|
let promise = this.haxelib(['setup', `${this.path}/lib`]);
|
|
promise = promise.then(() => this.haxelib(['upgrade', '--always']));
|
|
return promise;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param params
|
|
* @returns {*}
|
|
*
|
|
* {
|
|
* command: 'build',
|
|
* platform: 'flash',
|
|
* version: '1.0.0',
|
|
* lib: {},
|
|
* values: {},
|
|
* macro: [],
|
|
* outputFile: 'out.swf',
|
|
* }
|
|
*/
|
|
openfl(params) {
|
|
params = Object.assign({
|
|
version: null,
|
|
lib: [],
|
|
cp: [],
|
|
main: null,
|
|
values: {},
|
|
macro: [],
|
|
debug: false,
|
|
}, params);
|
|
|
|
const files = [];
|
|
let stream = null;
|
|
|
|
const bufferContents = (file, enc, callback) => {
|
|
// ToDo: check file not stream
|
|
files.push(file);
|
|
callback();
|
|
};
|
|
|
|
const endStream = (callback) => {
|
|
log(this.tag, colors.cyan(`openfl ${params.command} ${params.platform}`));
|
|
const args = ['-cwd', files[0].path, 'run', 'openfl', params.command, params.platform];
|
|
// lib
|
|
let lib = params.lib;
|
|
if (!Array.isArray(lib)) {
|
|
lib = Object.entries(lib).map(([k, v]) => `${k}:${v.split('@')[0]}`);
|
|
}
|
|
for (const item of lib) {
|
|
args.push(`--haxelib="${item}"`);
|
|
}
|
|
// cp
|
|
for (const item of params.cp) {
|
|
args.push(`--source="${item}"`);
|
|
}
|
|
if (params.main) {
|
|
args.push(`--app-main="${params.main}"`);
|
|
}
|
|
// macro
|
|
for (const macro of params.macro) {
|
|
args.push(`--haxeflag="--macro ${macro}"`);
|
|
}
|
|
for (let key of Object.keys(params.values)) {
|
|
const value = params.values[key];
|
|
if (value === true) {
|
|
args.push(`-D${key}`);
|
|
} else if (value) {
|
|
args.push(`-D${key}="${value}"`);
|
|
}
|
|
}
|
|
const buildDir = path.join(os.tmpdir(), 'build');
|
|
args.push(`--app-path="${buildDir}"`);
|
|
if (params.outputFile) {
|
|
args.push(`--app-file="${params.outputFile}"`);
|
|
}
|
|
if (params.version) args.push(`--meta-version=${params.version}`);
|
|
if (params.debug) {
|
|
args.push('-debug');
|
|
}
|
|
const target = `${buildDir}/${params.platform}/bin`;
|
|
rmdir(target);
|
|
this.haxelib(args).then(() => {
|
|
vfs.src(`${target}/**/*`).pipe(through.obj((file, enc, cb) => {
|
|
stream.push(file);
|
|
cb();
|
|
}, (cb) => {
|
|
callback();
|
|
cb();
|
|
}));
|
|
//callback();
|
|
}).catch((error) => {
|
|
stream.emit('error', new PluginError({plugin: this.name, message: error}));
|
|
callback();
|
|
});
|
|
};
|
|
|
|
return stream = through.obj(bufferContents, endStream);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param params
|
|
*
|
|
* {
|
|
* platform: 'neko',
|
|
* version: '1.0.0',
|
|
* values: {},
|
|
* macro: [],
|
|
* lib: [],
|
|
* src: [],
|
|
* main: 'Main.hx',
|
|
* outputFile: 'out.n',
|
|
* debug: false,
|
|
* }
|
|
*/
|
|
build(params) {
|
|
params = Object.assign({
|
|
version: null,
|
|
values: {},
|
|
lib: [],
|
|
macro: [],
|
|
debug: false,
|
|
}, params);
|
|
|
|
const files = [];
|
|
let stream = null;
|
|
|
|
const bufferContents = (file, enc, callback) => {
|
|
// ToDo: check file not stream
|
|
files.push(file);
|
|
callback();
|
|
};
|
|
|
|
const endStream = (callback) => {
|
|
log(this.tag, colors.cyan("haxe", params.platform), '=>', colors.magenta(params.outputFile));
|
|
const args = [];
|
|
// main
|
|
args.push('-main', params.main);
|
|
// lib
|
|
let lib = params.lib;
|
|
if (!Array.isArray(lib)) {
|
|
lib = Object.entries(lib).map(([k, v]) => `${k}:${v.split('@')[0]}`);
|
|
}
|
|
for (const item of lib) {
|
|
args.push('-lib', item);
|
|
}
|
|
// cp
|
|
for (const cp of params.cp) {
|
|
args.push('-cp', cp);
|
|
}
|
|
// macro
|
|
for (const macro of params.macro) {
|
|
args.push('--macro', `"${macro}"`);
|
|
}
|
|
for (let key of Object.keys(params.values)) {
|
|
const value = params.values[key];
|
|
if (value === true) {
|
|
args.push(`-D ${key}`);
|
|
} else if (value) {
|
|
args.push(`-D ${key}="${value}"`);
|
|
}
|
|
}
|
|
const tmpFile = tmp.generateFile();
|
|
args.push(`-${params.platform}`, tmpFile.path);
|
|
if (params.debug) {
|
|
args.push('-debug');
|
|
}
|
|
//console.log('haxe', args.join(' '));
|
|
this.haxe(args).then(() => {
|
|
const out = new Vinyl({
|
|
path: params.outputFile,
|
|
//contents: fs.createReadStream(tmpFile.path),
|
|
contents: fs.readFileSync(tmpFile.path),
|
|
});
|
|
stream.push(out);
|
|
callback();
|
|
}).catch((error) => {
|
|
stream.emit('error', new PluginError({plugin: this.name, message: error}));
|
|
callback();
|
|
});
|
|
};
|
|
|
|
return stream = through.obj(bufferContents, endStream);
|
|
}
|
|
}
|
|
|
|
Haxe.ID = 'haxe';
|
|
|
|
Haxe.VERSION_3_4_0 = '3.4.0';
|
|
Haxe.VERSION_3_4_2 = '3.4.2';
|
|
Haxe.VERSION_3_4_3 = '3.4.3';
|
|
Haxe.VERSION_3_4_7 = '3.4.7';
|
|
Haxe.VERSION_3 = Haxe.VERSION_3_4_7;
|
|
Haxe.VERSION = Haxe.VERSION_3;
|
|
|
|
module.exports = Haxe; |