@neonwilderness/moveskins 1.1.0

package/.env.example

@@ -0,0 +1,2 @@
+USER=someUserIDWithAdminRights
+PASSWORD=somePassword

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 1.1.0 (31.03.2026)
+- Migrate to Vite+
+- Swap Ava for Vitest
+- Generate minified dist js file

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NeonWilderness
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# moveskins
+
+Download/Upload/Compare modified skins for selected aliases on Twoday

package/dist/index.js

@@ -0,0 +1,206 @@
+import e from "yargs/yargs";
+import t from "chalk";
+import * as n from "@neonwilderness/twoday";
+import { deleteSync as r } from "del";
+import { existsSync as i, mkdirSync as a, readFileSync as o, readdirSync as s, writeFileSync as c } from "node:fs";
+import { resolve as l } from "node:path";
+import { config as u } from "dotenv-safe";
+//#region src/_utils.js
+var d = l(process.cwd(), "skins"), f = l(process.cwd(), "backup"), p = l(d, "skinRegister.json"), m = {
+	data: void 0,
+	hasChanged: !1,
+	load() {
+		return this.data = i(p) ? JSON.parse(o(p).toString()) : {}, this.data;
+	},
+	store() {
+		this.hasChanged &&= (c(p, JSON.stringify(this.data, null, 2)), !1);
+	},
+	hasData(e) {
+		return this.data === void 0 && this.load(), this.data.hasOwnProperty(e);
+	},
+	getData(e) {
+		let t = e.endsWith(".skin") ? e.substr(0, e.length - 5) : e;
+		if (this.hasData(t)) {
+			let { title: e, description: n } = this.data[t];
+			return {
+				name: t,
+				title: e,
+				description: n
+			};
+		} else return {
+			name: t,
+			title: t,
+			description: ""
+		};
+	},
+	setData(e, t, n) {
+		this.hasData(e) || (this.data[e] = {
+			title: t,
+			description: n
+		}, this.hasChanged = !0);
+	},
+	deleteData(e) {
+		this.hasData(e) && delete this.data[e];
+	}
+}, h = (e, t) => l(t ? f : d, e), g = (e, t) => {
+	try {
+		r(e.map((e) => l(h(e, t), "*.skin")));
+	} catch (e) {
+		console.log(`cleanupAliasFolder ended with error: ${e.toString()}.`), process.exit(1);
+	}
+}, _ = (e, t) => {
+	let n = h(e, t);
+	return i(n) ? s(n).filter((e) => e.endsWith(".skin")) : [];
+}, v = (e, t) => e.split(t).filter((e) => e.trim().length).map((e) => e.toLowerCase()), y = async (e, n, r) => {
+	try {
+		await e.login();
+		for (let o of n) {
+			console.log(t.green(`\nNow processing alias "${o}"...`));
+			let n = h(o, r.backup), s = await e.getModifiedSkins(o);
+			s.length && !i(n) && a(n), console.log(t.yellow(`${o} has ${s.length} modified skin${s.length === 1 ? "" : "s"}`)), r.skin && console.log(t.yellow(`Filtering skins for ${r.skin}.`));
+			for (let i of s) {
+				if (r.skin && !r.skin.test(i.name)) continue;
+				console.log(t.gray(`Reading "${i.name}".`));
+				let { title: a, description: o, skin: s } = await e.getSkin(i);
+				m.setData(i.name, a, o), c(l(n, `${i.name}.skin`), s);
+			}
+		}
+		console.log(t.green("Download completed."));
+	} catch (e) {
+		console.log(t.red(`Error while downloading skins: ${e}`));
+	} finally {
+		m.store();
+	}
+}, b = async (e, n, r) => {
+	try {
+		await e.login();
+		for (let i of n) {
+			console.log(t.green(`\nNow processing alias "${i}"...`));
+			let n = _(i, r.backup);
+			console.log(t.yellow(`${i} has ${n.length} local skins. `) + t.red(`${n.length === 0 ? "Got nothing to do!" : ""}`)), r.skin && console.log(t.yellow(`Filtering skins for ${r.skin}.`));
+			let a = await e.getModifiedSkins(i), s = new Set(a.map((e) => e.name)), c = h(i, r.backup);
+			for (let a of n) {
+				if (!a.endsWith(".skin") || r.skin && !r.skin.test(a)) continue;
+				let n = m.getData(a);
+				n.content = o(l(c, a)).toString().replace(/\r\n/g, "\n"), console.log(t.blue(`Now updating skin ${n.name} (len=${n.content.length}).`)), await e.updateSkin(i, n.name, {
+					title: n.title,
+					description: n.description,
+					skin: n.content,
+					diff: r.debug
+				}), console.log(t.green(`Update request completed for skin: ${n.name}`)), s.has(n.name) && s.delete(n.name);
+			}
+			s.size > 0 && (console.log(t.blue(`\nFollowing skins exist on "${i}" and were not touched by this upload:`)), s.forEach((e) => console.log(`--> ${t.blue(e)}`)));
+		}
+		console.log(t.green("Upload completed."));
+	} catch (e) {
+		console.log(t.red(`Error while uploading skins: ${e}`));
+	}
+}, x = {
+	different: "cyan",
+	identical: "grey",
+	new: "green",
+	untouched: "grey"
+}, S = (e, t) => e.name < t.name ? -1 : e.name > t.name ? 1 : 0, C = async (e, n) => {
+	let r = { aliases: [] };
+	try {
+		typeof n == "string" && (n = [n]), await e.login();
+		for (let i of n) {
+			let n = {
+				header: "",
+				skins: []
+			}, a = i, s = i;
+			i.includes(":") && ([a, s] = v(i, ":")), n.header = `Now comparing local alias "${a}" to remote ${e.platform.toUpperCase()} alias "${s}@${e.fullDomain}" [${(/* @__PURE__ */ new Date()).toLocaleString()}] ...`, console.log(t.green(`\n${n.header}`)), n.header = n.header.replace("local", "<ins>local</ins>").replace("remote", "<del>remote</del>");
+			let c = h(a, !1), u = _(a, !1).map((e) => {
+				let t = m.getData(e);
+				return t.skin = o(l(c, e)).toString().replace(/\r\n/g, "\n"), t;
+			}).sort(S), d = await e.getModifiedSkins(s), f = [];
+			for (let t of d) f.push(e.getSkin(t));
+			let p = (await Promise.all(f)).map((e) => {
+				let { name: t, title: n, description: r, skin: i } = e;
+				return {
+					name: t,
+					title: n,
+					description: r,
+					skin: i
+				};
+			}).sort(S), g = 0, y = 0;
+			for (; g < u.length && y < p.length;) {
+				let r = g < u.length ? u[g].name : "￿", i = y < p.length ? p[y].name : "￿", a = {
+					open: !1,
+					results: []
+				};
+				if (r === i) {
+					console.log(t.white(`Processing skin ${t.italic(r)}`));
+					let n = e.diffSkin(r, p[y], u[g]);
+					a.class = n.skinChanged ? "different" : "identical", a.open = n.skinChanged, a.text = `${n.skinName} is ${a.class}.`, a.results = n.results, g++, y++;
+				} else r < i ? (a.text = `Local skin ${r} missing on remote. Will be created upon update!`, a.class = "new", g++) : (a.text = `Remote skin ${i} without local counterpart. Will remain untouched upon update!`, a.class = "untouched", y++), console.log(t[x[a.class]](a.text));
+				n.skins.push(a);
+			}
+			r.aliases.push(n);
+		}
+		c(l(process.cwd(), "./src/template.json"), JSON.stringify(r, null, 2));
+		let i = o(l(process.cwd(), "./src/template.html")).toString().trim();
+		c(l(process.cwd(), "./report.html"), i.replace("$$templateJSON", `(${JSON.stringify(r, null, 2)})`)), console.log(t.green("Local/Remote comparison completed."));
+	} catch (e) {
+		console.log(t.red(`Error while comparing skins: ${e}`));
+	}
+}, w = e(process.argv.slice(2)).options({
+	from: {
+		alias: "f",
+		description: "Platform where to download the skins from: \"dev\" or \"prod\"",
+		type: "string"
+	},
+	to: {
+		alias: "t",
+		description: "Platform where to compare or upload the skins to: \"dev\" or \"prod\"",
+		type: "string"
+	},
+	alias: {
+		alias: "a",
+		description: "One or more alias blog name/s delimited by comma (no space)",
+		type: "string"
+	},
+	skin: {
+		alias: "s",
+		description: "Skin selection string (regex) to filter the skins to upload",
+		type: "string"
+	},
+	backup: {
+		alias: "b",
+		description: "Backup skins to the local /backup folder to preserve their former status",
+		type: "boolean"
+	},
+	clean: {
+		default: !1,
+		description: "Cleanup (delete) the alias local skin directory to remove potential old files before new download",
+		type: "boolean"
+	},
+	compare: {
+		default: !1,
+		description: "Compare the local alias skin directory to a remote location (prod/dev)",
+		type: "boolean"
+	},
+	debug: {
+		default: !1,
+		description: "Issue more logging messages and diff analysis (for upload function)",
+		type: "boolean"
+	}
+}).argv;
+u(), !w.from && !w.to && (console.log("Desired action must be specified with --from=dev|prod or --to=dev|prod"), process.exit(1)), w.from && w.to && (console.log("You cannot specify --from=dev|prod AND --to=dev|prod in one run"), process.exit(1)), w.compare && !w.to && (console.log("You must specify a target platform with --to=dev|prod when comparing skins"), process.exit(1)), w.alias || (console.log("You must specify the desired alias(es) with --alias=name1,name2,... OR --alias=*"), process.exit(1));
+var T = (w.from || w.to).toLowerCase(), E = new n.Twoday(T, { delay: 100 }), D = w.alias === "*" ? [
+	"www",
+	"info",
+	"help",
+	"top"
+] : v(w.alias, ",");
+if (w.compare) D.length === 1 && D[0].includes(":") && console.log(`Start comparing local skin files of alias${D.length > 1 ? "es" : ""} ${t.yellow(D.join(", "))} to ${t.green(E.fullDomain)}...`), C(E, D);
+else {
+	let e = w.from ? "down" : "up", n = w.from ? "from" : "to", r = w.from ? y : b;
+	e === "down" && w.clean && g(D, w.backup), console.log(`Start ${e}loading modified skins of alias${D.length > 1 ? "es" : ""} ${t.yellow(D.join(", "))} ${n} remote ${t.green(E.fullDomain)}...`), r(E, D, {
+		backup: w.backup,
+		debug: w.debug,
+		skin: w.skin ? new RegExp(w.skin) : null
+	});
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@neonwilderness/moveskins",
+  "version": "1.1.0",
+  "description": "Download/Upload/Compare modified skins for selected aliases on Twoday",
+  "keywords": [
+    "antville",
+    "migration",
+    "skins",
+    "twoday"
+  ],
+  "license": "MIT",
+  "author": "NeonWilderness",
+  "files": [
+    "dist",
+    "src",
+    ".env.example",
+    "CHANGELOG.md",
+    "LICENSE",
+    "pack*.json",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": "./dist/index.js",
+  "scripts": {
+    "update": "ncu -u && npm i",
+    "backup": "node ./src/index --backup --alias=www --from=prod",
+    "dev": "vp run node ./src/index.js",
+    "build": "vp build",
+    "check": "vp check",
+    "create": "node ./src/create --skin=Site.testskin --alias=talkstraight",
+    "//": "For compare function, live-server module must be installed globally!",
+    "compare": "node ./src/index --compare --alias=help --to=dev && npm run report",
+    "compare:blogs": "node ./src/index --compare --alias=foundation:info --to=prod && npm run report",
+    "download": "node ./src/index --alias=foundation --from=prod",
+    "download2": "node ./src/index --alias=info,help --from=prod",
+    "download:clean": "node ./src/index --alias=recycle --from=prod --clean",
+    "download:core": "node ./src/index --alias=* --from=prod",
+    "download:core:clean": "node ./src/index --alias=* --from=prod --clean",
+    "report": "live-server --open=./report.html --quiet",
+    "restore": "node ./src/index --backup --alias=www --to=dev",
+    "upload": "node ./src/index --alias=neonwilderness --to=dev",
+    "upload2": "node ./src/index --alias=info,help --to=dev",
+    "upload:core": "node ./src/index --alias=* --to=dev",
+    "images": "node ./src/images --alias=recycle --to=prod",
+    "lonely": "node ./util/buildLonelyBlogs",
+    "test": "vp test",
+    "test:ui": "vp test --ui"
+  },
+  "dependencies": {
+    "@neonwilderness/twoday": "^0.6.1",
+    "chalk": "^5.6.2",
+    "del": "^8.0.1",
+    "dotenv-safe": "^9.1.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "4.1.1",
+    "slash": "^5.1.0",
+    "vite-plus": "^0.1.15"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/_compare.js

@@ -0,0 +1,130 @@
+/**
+ * Compare
+ * =======
+ *
+ */
+import chalk from "chalk";
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { aliasSkinFolder, getLocalSkins, skinRegister, splitAliases } from "./_utils.js";
+
+const classToColor = {
+  different: "cyan",
+  identical: "grey",
+  new: "green",
+  untouched: "grey",
+};
+
+/**
+ * Sorting function sorts objects by their name property alphabetically
+ * @param {object} skinA
+ * @param {object} skinB
+ * @returns -1/1/0 depending on name comparison
+ */
+const skinsByName = (skinA, skinB) => {
+  if (skinA.name < skinB.name) return -1;
+  if (skinA.name > skinB.name) return 1;
+  return 0;
+};
+
+/**
+ * Compares all local skins of selected aliases to the target platform skins
+ * @param {Object} td Twoday access class object instance
+ * @param {String[] | String} aliases One or more target alias(es), can also be a single alias string
+ * @returns {Promise}
+ */
+const compareLocalToRemoteSkins = async (td, aliases) => {
+  const alpineView = { aliases: [] };
+  try {
+    if (typeof aliases === "string") aliases = [aliases];
+
+    await td.login();
+
+    for (let alias of aliases) {
+      let aliasView = { header: "", skins: [] };
+      let localAlias = alias;
+      let remoteAlias = alias;
+      if (alias.includes(":")) [localAlias, remoteAlias] = splitAliases(alias, ":");
+      aliasView.header = `Now comparing local alias "${localAlias}" to remote ${td.platform.toUpperCase()} alias "${remoteAlias}@${td.fullDomain}" [${new Date().toLocaleString()}] ...`;
+      console.log(chalk.green(`\n${aliasView.header}`));
+      aliasView.header = aliasView.header
+        .replace("local", "<ins>local</ins>")
+        .replace("remote", "<del>remote</del>");
+
+      const aliasSkinDir = aliasSkinFolder(localAlias, false);
+      const localSkinData = getLocalSkins(localAlias, false)
+        .map((skinFile) => {
+          const localSkin = skinRegister.getData(skinFile);
+          localSkin.skin = readFileSync(resolve(aliasSkinDir, skinFile))
+            .toString()
+            .replace(/\r\n/g, "\n");
+          return localSkin;
+        })
+        .sort(skinsByName);
+
+      const modifiedSkins = await td.getModifiedSkins(remoteAlias);
+      let remoteSkins = [];
+      for (let skin of modifiedSkins) {
+        remoteSkins.push(td.getSkin(skin));
+      }
+      const remoteSkinEnriched = await Promise.all(remoteSkins);
+      const remoteSkinData = remoteSkinEnriched
+        .map((data) => {
+          const { name, title, description, skin } = data;
+          return { name, title, description, skin };
+        })
+        .sort(skinsByName);
+
+      const endOfSkins = String.fromCharCode(0xffff);
+      let l = 0;
+      let r = 0;
+      while (l < localSkinData.length && r < remoteSkinData.length) {
+        const lName = l < localSkinData.length ? localSkinData[l].name : endOfSkins;
+        const rName = r < remoteSkinData.length ? remoteSkinData[r].name : endOfSkins;
+        let skinView = { open: false, results: [] };
+        if (lName === rName) {
+          console.log(chalk.white(`Processing skin ${chalk.italic(lName)}`));
+          let skinDiff = td.diffSkin(lName, remoteSkinData[r], localSkinData[l]);
+          skinView.class = skinDiff.skinChanged ? "different" : "identical";
+          skinView.open = skinDiff.skinChanged;
+          skinView.text = `${skinDiff.skinName} is ${skinView.class}.`;
+          skinView.results = skinDiff.results;
+          l++;
+          r++;
+        } else {
+          if (lName < rName) {
+            skinView.text = `Local skin ${lName} missing on remote. Will be created upon update!`;
+            skinView.class = "new";
+            l++;
+          } else {
+            // lName > rName
+            skinView.text = `Remote skin ${rName} without local counterpart. Will remain untouched upon update!`;
+            skinView.class = "untouched";
+            r++;
+          }
+          console.log(chalk[classToColor[skinView.class]](skinView.text));
+        }
+        aliasView.skins.push(skinView);
+      }
+      alpineView.aliases.push(aliasView);
+    }
+
+    writeFileSync(
+      resolve(process.cwd(), "./src/template.json"),
+      JSON.stringify(alpineView, null, 2),
+    );
+    const alpineTemplate = readFileSync(resolve(process.cwd(), "./src/template.html"))
+      .toString()
+      .trim();
+    writeFileSync(
+      resolve(process.cwd(), "./report.html"),
+      alpineTemplate.replace("$$templateJSON", `(${JSON.stringify(alpineView, null, 2)})`),
+    );
+
+    console.log(chalk.green("Local/Remote comparison completed."));
+  } catch (e) {
+    console.log(chalk.red(`Error while comparing skins: ${e}`));
+  }
+};
+
+export { compareLocalToRemoteSkins };

package/src/_download.js

@@ -0,0 +1,51 @@
+/**
+ * Download
+ * ========
+ *
+ */
+import chalk from "chalk";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { aliasSkinFolder, skinRegister } from "./_utils.js";
+
+/**
+ * Downloads all customized skins of one or more aliases and stores them in appropriate
+ * subdirectories for subsequent manual edits (or just as backup)
+ * @param {Object} td Twoday class object instance
+ * @param {String[]} aliases array of aliases (one or more blog names)
+ */
+const downloadModifiedSkins = async (td, aliases, options) => {
+  try {
+    await td.login();
+
+    for (let alias of aliases) {
+      console.log(chalk.green(`\nNow processing alias "${alias}"...`));
+      const aliasSkinDir = aliasSkinFolder(alias, options.backup);
+      const modifiedSkins = await td.getModifiedSkins(alias);
+
+      if (modifiedSkins.length && !existsSync(aliasSkinDir)) mkdirSync(aliasSkinDir);
+      console.log(
+        chalk.yellow(
+          `${alias} has ${modifiedSkins.length} modified skin${modifiedSkins.length !== 1 ? "s" : ""}`,
+        ),
+      );
+      if (options.skin) console.log(chalk.yellow(`Filtering skins for ${options.skin}.`));
+
+      for (let modSkin of modifiedSkins) {
+        if (options.skin && !options.skin.test(modSkin.name)) continue;
+        console.log(chalk.gray(`Reading "${modSkin.name}".`));
+        const { title, description, skin } = await td.getSkin(modSkin);
+
+        skinRegister.setData(modSkin.name, title, description);
+        writeFileSync(resolve(aliasSkinDir, `${modSkin.name}.skin`), skin);
+      }
+    }
+    console.log(chalk.green("Download completed."));
+  } catch (e) {
+    console.log(chalk.red(`Error while downloading skins: ${e}`));
+  } finally {
+    skinRegister.store();
+  }
+};
+
+export { downloadModifiedSkins };

package/src/_upload.js

@@ -0,0 +1,68 @@
+/**
+ * Upload
+ * ======
+ *
+ */
+import chalk from "chalk";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { aliasSkinFolder, getLocalSkins, skinRegister } from "./_utils.js";
+
+/**
+ * Uploads all local skins of selected aliases to the target platform
+ * @param {Object} td Twoday class object instance
+ * @param {String[]} aliases One or more target alias(es)
+ * @returns {Promise}
+ */
+const uploadModifiedSkins = async (td, aliases, options) => {
+  try {
+    await td.login();
+
+    for (let alias of aliases) {
+      console.log(chalk.green(`\nNow processing alias "${alias}"...`));
+      const localSkinFiles = getLocalSkins(alias, options.backup);
+      console.log(
+        chalk.yellow(`${alias} has ${localSkinFiles.length} local skins. `) +
+          chalk.red(`${localSkinFiles.length === 0 ? "Got nothing to do!" : ""}`),
+      );
+      if (options.skin) console.log(chalk.yellow(`Filtering skins for ${options.skin}.`));
+
+      const modSkins = await td.getModifiedSkins(alias);
+      const currentSkins = new Set(modSkins.map((el) => el.name));
+      const aliasSkinDir = aliasSkinFolder(alias, options.backup);
+
+      for (let skinFile of localSkinFiles) {
+        if (!skinFile.endsWith(".skin")) continue;
+        if (options.skin && !options.skin.test(skinFile)) continue;
+
+        const skin = skinRegister.getData(skinFile);
+        skin.content = readFileSync(resolve(aliasSkinDir, skinFile))
+          .toString()
+          .replace(/\r\n/g, "\n");
+
+        console.log(chalk.blue(`Now updating skin ${skin.name} (len=${skin.content.length}).`));
+        await td.updateSkin(alias, skin.name, {
+          title: skin.title,
+          description: skin.description,
+          skin: skin.content,
+          diff: options.debug,
+        });
+        console.log(chalk.green(`Update request completed for skin: ${skin.name}`));
+
+        if (currentSkins.has(skin.name)) currentSkins.delete(skin.name);
+      }
+
+      if (currentSkins.size > 0) {
+        console.log(
+          chalk.blue(`\nFollowing skins exist on "${alias}" and were not touched by this upload:`),
+        );
+        currentSkins.forEach((skinName) => console.log(`--> ${chalk.blue(skinName)}`));
+      }
+    }
+    console.log(chalk.green("Upload completed."));
+  } catch (e) {
+    console.log(chalk.red(`Error while uploading skins: ${e}`));
+  }
+};
+
+export { uploadModifiedSkins };

package/src/_utils.js

@@ -0,0 +1,107 @@
+/**
+ * Utility functions
+ * =================
+ *
+ */
+import { deleteSync } from "del";
+import { existsSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+// Read centrally stored skin header data (name => title, description)
+const skinsFolder = resolve(process.cwd(), "skins");
+const backupFolder = resolve(process.cwd(), "backup");
+const pathToRegister = resolve(skinsFolder, "skinRegister.json");
+const skinRegister = {
+  data: undefined,
+  hasChanged: false,
+  load() {
+    this.data = existsSync(pathToRegister)
+      ? JSON.parse(readFileSync(pathToRegister).toString())
+      : {};
+    return this.data;
+  },
+  store() {
+    if (this.hasChanged) {
+      writeFileSync(pathToRegister, JSON.stringify(this.data, null, 2));
+      this.hasChanged = false;
+    }
+  },
+  hasData(skinName) {
+    if (typeof this.data === "undefined") this.load();
+    return this.data.hasOwnProperty(skinName);
+  },
+  getData(skinFileOrName) {
+    const name = skinFileOrName.endsWith(".skin")
+      ? skinFileOrName.substr(0, skinFileOrName.length - 5)
+      : skinFileOrName;
+    if (this.hasData(name)) {
+      const { title, description } = this.data[name];
+      return { name, title, description };
+    } else return { name, title: name, description: "" };
+  },
+  setData(skinName, title, description) {
+    if (!this.hasData(skinName)) {
+      this.data[skinName] = { title, description };
+      this.hasChanged = true;
+    }
+  },
+  deleteData(skinName) {
+    if (this.hasData(skinName)) delete this.data[skinName];
+  },
+};
+
+/**
+ * Returns the path to the local alias skin folder
+ * @param {String} alias A single blog alias, e.g. info or help or wiki or any other Twoday alias
+ * @param {boolean} isBackup true=argv.backup has been activated
+ * @returns {String} path
+ */
+const aliasSkinFolder = (alias, isBackup) => resolve(isBackup ? backupFolder : skinsFolder, alias);
+
+/**
+ * Cleans the local alias' skin folder, i.e. deletes all skin files in the local folder
+ * @param {String} aliases Array of blog aliases
+ * @returns {void}
+ */
+const cleanupAliasFolder = (aliases, isBackup) => {
+  try {
+    deleteSync(aliases.map((alias) => resolve(aliasSkinFolder(alias, isBackup), "*.skin")));
+  } catch (err) {
+    console.log(`cleanupAliasFolder ended with error: ${err.toString()}.`);
+    process.exit(1);
+  }
+};
+
+/**
+ * Returns all files in a given alias directory or an empty array if it doesn't exist
+ * @param {String} alias Blog alias
+ * @returns {String[]} Array of file strings or []
+ */
+const getLocalSkins = (alias, isBackup) => {
+  const aliasSkinDir = aliasSkinFolder(alias, isBackup);
+  return existsSync(aliasSkinDir)
+    ? readdirSync(aliasSkinDir).filter((file) => file.endsWith(".skin"))
+    : [];
+};
+
+/**
+ * Splits an alias param string based on a given delimiter
+ * @param {String} aliases, e.g. "info,foundation" or "foundation:info"
+ * @param {String} delimiter, e.g. "," or ":"
+ * @returns {String[]} Array of trimmed, lowercased strings
+ */
+const splitAliases = (aliases, delimiter) => {
+  return aliases
+    .split(delimiter)
+    .filter((alias) => alias.trim().length)
+    .map((alias) => alias.toLowerCase());
+};
+
+export {
+  pathToRegister,
+  skinRegister,
+  aliasSkinFolder,
+  cleanupAliasFolder,
+  getLocalSkins,
+  splitAliases,
+};