refactor: rewrite on typescript

This commit is contained in:
2026-10-13 21:11:57 +03:00
parent be54ce5d25
commit f735be8bf9
40 changed files with 2333 additions and 2175 deletions
+143
View File
@@ -0,0 +1,143 @@
import os from "os";
import path from "path";
export interface ConfigParams {
name?: string;
main?: string;
preloader?: string;
sources?: string[];
assets?: string[];
libs?: LibDef[] | Record<string, string>;
macros?: string[];
flags?: string[];
meta?: ConfigMeta;
key?: SignKey;
android?: AndroidPreset[];
}
export interface ConfigMeta {
title?: string;
filename?: string;
icon?: string;
version?: string;
pack?: string;
author?: string;
company?: string;
width?: number;
height?: number;
mobileWidth?: number;
mobileHeight?: number;
fps?: number;
}
export interface LibDef {
name: string;
version: string;
git?: string;
branch?: string;
}
export interface AndroidPreset {
path: string;
extensions: string[];
}
export interface SignKey {
store: string;
pass: string;
}
export class Config {
public name: string;
public main: string;
public preloader: string | null;
public sources: string[];
public assets: string[];
public libs: LibDef[];
public macros: string[];
public flags: string[];
public icon: string | null;
public meta: ConfigMeta;
public key: SignKey | null;
public android: AndroidPreset[];
private _params: ConfigParams[];
constructor(params?: ConfigParams) {
this._params = [];
this.name = "";
this.main = "";
this.preloader = null;
this.sources = [];
this.assets = [];
this.libs = [];
this.macros = [];
this.flags = [];
this.icon = null;
this.meta = {
title: null,
filename: null,
icon: null,
version: null,
pack: null,
author: null,
company: null,
width: 800,
height: 600,
mobileWidth: null,
mobileHeight: null,
fps: 60,
};
this.key = null;
this.android = [];
if (params) {
this.update(params);
this.afterUpdate();
}
}
static absolutePath(file: string): string {
const result = path.resolve(process.cwd(), path.normalize(file));
return os.type() === "Windows_NT" ? result.split("\\").join("/") : result;
}
update(params: ConfigParams) {
this._params.push(params);
if (params.name !== undefined) this.name = params.name;
if (params.main !== undefined) this.main = params.main;
if (params.preloader !== undefined) this.preloader = params.preloader;
if (params.sources !== undefined) this.sources = this.sources.concat(params.sources.map(Config.absolutePath));
if (params.assets !== undefined) this.assets = this.assets.concat(params.assets.map(Config.absolutePath));
if (params.libs !== undefined)
this.libs = this.libs.concat(
Array.isArray(params.libs)
? params.libs
: Object.entries(params.libs).map(([k, v]) => ({ name: k, version: v })),
);
if (params.macros !== undefined) this.macros = this.macros.concat(params.macros);
if (params.flags !== undefined) this.flags = this.flags.concat(params.flags);
if (params.meta !== undefined) this.meta = { ...this.meta, ...params.meta };
if (params.key !== undefined) this.key = params.key;
if (params.android !== undefined)
this.android = this.android.concat(
params.android.map((item) => ({ path: Config.absolutePath(item.path), extensions: item.extensions })),
);
if (this.meta.icon) this.icon = Config.absolutePath(this.meta.icon);
}
afterUpdate() {
if (this.meta.mobileWidth === null) this.meta.mobileWidth = this.meta.width;
if (this.meta.mobileHeight === null && this.meta.mobileWidth)
this.meta.mobileHeight = Math.round(this.meta.mobileWidth / 2.222222222);
}
branch(params: ConfigParams) {
const result = new Config();
for (const params of this._params) {
result.update(params);
}
result.update(params);
result.afterUpdate();
return result;
}
}
+142
View File
@@ -0,0 +1,142 @@
import progress from "cli-progress";
import fs from "fs";
import fse from "fs-extra";
import got from "got";
import os from "os";
import path from "path";
import ps from "promise-streams";
import tar from "tar";
import unzip from "unzip-stream";
import { Log } from "../common/log";
export class Downloader {
static bar: progress.MultiBar;
static createProgressBar() {
if (Downloader.bar == null) {
Downloader.bar = new progress.MultiBar(
{
clearOnComplete: true,
},
progress.Presets.shades_grey,
);
}
return Downloader.bar.create();
}
static releaseProgressBar(bar: progress.MultiBar) {
bar.stop();
if (Downloader.bar != null) {
Downloader.bar.remove(bar);
if (Downloader.bar.bars.length === 0) {
Downloader.bar.stop();
Downloader.bar = null;
}
}
}
static download(url: string, dest: string, strip = 1, executable = false) {
fse.ensureDirSync(dest);
const bar = Downloader.createProgressBar();
let stream = got.stream(url);
stream = stream
.on("request", (r: any) => {
if (bar) bar.start(1, 0);
})
.on("downloadProgress", (p: any) => {
if (bar) {
bar.setTotal(p.total);
bar.update(p.transferred);
if (p.total === p.transferred) {
Downloader.releaseProgressBar(bar);
}
}
});
if (url.endsWith(".zip")) {
stream = stream.pipe(unzip.Parse()).on("entry", (entry: any) => {
const filePath = entry.path.split("/").slice(strip).join(path.sep);
if (filePath.length > 0) {
if (entry.type === "Directory") {
fse.ensureDirSync(path.join(dest, path.normalize(filePath)));
} else if (entry.type === "File") {
const fullFilePath = path.join(dest, path.normalize(filePath));
const dirPath = path.dirname(fullFilePath);
if (!fs.existsSync(dirPath)) {
fse.ensureDirSync(dirPath);
}
entry.pipe(
fs.createWriteStream(path.join(dest, path.normalize(filePath)), {
// ToDo: zip entry file mode?
mode: executable ? 0o755 : undefined,
}),
);
}
} else {
entry.autodrain();
}
});
} else if (url.endsWith("tar.gz")) {
stream = stream.pipe(tar.x({ C: dest, strip: strip }));
} else {
stream = stream.pipe(fs.createWriteStream(path.join(dest, url.split("/").pop()!)));
}
return ps.wait(stream);
}
}
export class Sdk {
static _dir: string;
static set dir(value) {
Sdk._dir = value;
}
static get dir() {
return Sdk._dir || path.join(os.homedir(), "sdk");
}
static path(name: string, version: string) {
return path.join(this.dir, name, version);
}
public name: string;
public version: string;
public log: Log;
public path: string;
constructor(name: string, version: string) {
this.name = name;
this.log = new Log(name);
this.version = version;
this.path = Sdk.path(name, version);
}
get intVersion() {
const vArr = this.version.split("\.").reverse();
let m = 1;
let r = 0;
for (let v of vArr) {
r += parseInt(v) * m;
m *= 10;
}
return r;
}
get prepared(): boolean {
throw "Not implemented";
}
get link(): string {
throw "Not implemented";
}
prepare(strip = 1): Promise<any> {
this.log.i("version: *%s*", this.version);
if (this.prepared) {
return Promise.resolve();
} else {
this.log.i("download: *%s*", this.link);
return Downloader.download(this.link, this.path, strip);
}
}
}
+15
View File
@@ -0,0 +1,15 @@
export const BuildSystem = {
HAXE: "haxe",
OPENFL: "openfl",
ADOBE_AIR: "adobe_air",
};
export const Platform = {
FLASH: "flash",
HTML5: "html5",
LINUX: "linux",
WINDOWS: "windows",
ANDROID: "android",
NEKO: "neko",
CPP: "cpp",
};