polyglot-cli
Version:
Infinum Polyglot CLI
1,464 lines • 127 kB
JavaScript
#!/usr/bin/env node
function _array_like_to_array(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
return arr2;
}
function _array_with_holes(arr) {
if (Array.isArray(arr)) return arr;
}
function _array_without_holes(arr) {
if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _assert_this_initialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _class_call_check(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get;
} else {
_get = function get(target, property, receiver) {
var base = _super_prop_base(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(receiver || target);
}
return desc.value;
};
}
return _get(target, property, receiver || target);
}
function _get_prototype_of(o) {
_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _get_prototype_of(o);
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
if (superClass) _set_prototype_of(subClass, superClass);
}
function _instanceof(left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return !!right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
}
function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _iterable_to_array_limit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally{
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally{
if (_d) throw _e;
}
}
return _arr;
}
function _non_iterable_rest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _non_iterable_spread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) {
symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
}
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _possible_constructor_return(self, call) {
if (call && (_type_of(call) === "object" || typeof call === "function")) {
return call;
}
return _assert_this_initialized(self);
}
function _set_prototype_of(o, p) {
_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _set_prototype_of(o, p);
}
function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _super_prop_base(object, property) {
while(!Object.prototype.hasOwnProperty.call(object, property)){
object = _get_prototype_of(object);
if (object === null) break;
}
return object;
}
function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _type_of(obj) {
"@swc/helpers - typeof";
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _is_native_reflect_construct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
return true;
} catch (e) {
return false;
}
}
function _create_super(Derived) {
var hasNativeReflectConstruct = _is_native_reflect_construct();
return function _createSuperInternal() {
var Super = _get_prototype_of(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = _get_prototype_of(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possible_constructor_return(this, result);
};
}
function _ts_generator(thisArg, body) {
var f, y, t, g, _ = {
label: 0,
sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
},
trys: [],
ops: []
};
return(g = {
next: verb(0),
"throw": verb(1),
"return": verb(2)
}, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g);
function verb(n) {
return function(v) {
return step([
n,
v
]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while(_)try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [
op[0] & 2,
t.value
];
switch(op[0]){
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return {
value: op[1],
done: false
};
case 5:
_.label++;
y = op[1];
op = [
0
];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [
6,
e
];
y = 0;
} finally{
f = t = 0;
}
if (op[0] & 5) throw op[1];
return {
value: op[0] ? op[1] : void 0,
done: true
};
}
}
var _this = this;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __require = /* @__PURE__ */ function(x) {
return typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: function(a, b) {
return (typeof require !== "undefined" ? require : a)[b];
}
}) : x;
}(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw new Error('Dynamic require of "' + x + '" is not supported');
});
var __export = function(target, all) {
for(var name in all)__defProp(target, name, {
get: all[name],
enumerable: true
});
};
var __decorateClass = function(decorators, target, key, kind) {
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
for(var i = decorators.length - 1, decorator; i >= 0; i--)if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
if (kind && result) __defProp(target, key, result);
return result;
};
// src/index.ts
import program5 from "commander";
import { Response } from "@datx/jsonapi";
// src/state/index.ts
import { Collection } from "@datx/core";
import { jsonapi as jsonapi7 } from "@datx/jsonapi";
import { homedir } from "os";
// package.json
var version = "2.3.0";
var package_default = {
name: "polyglot-cli",
version: version,
description: "Infinum Polyglot CLI",
main: "dist/index.js",
scripts: {
lint: "eslint 'src/**/*.ts'",
test: "jest --coverage",
watch: "jest --watch --coverage",
publish: "changeset publish",
precommit: "npm run lint && npm test",
prepublishOnly: "npm run build",
build: "tsup src/index.ts --format cjs,esm --clean --legacy-output",
prepare: "husky install"
},
bin: {
polyglot: "./dist/index.js"
},
keywords: [
"i18n",
"infinum",
"polyglot",
"cli"
],
author: "Infinum <javascript.team@infinum.co>",
license: "UNLICENCED",
dependencies: {
"@datx/core": "^3.0.0",
"@datx/jsonapi": "^3.0.0",
colors: "^1.4.0",
commander: "^5.0.0",
"fs-extra": "~11.1.1",
inquirer: "~8.2.5",
lodash: "^4.17.20",
"node-fetch": "^2.6.1",
progress: "^2.0.3"
},
devDependencies: {
"@changesets/cli": "~2.26.1",
"@commitlint/cli": "~17.6.3",
"@commitlint/config-conventional": "~17.6.3",
"@infinumjs/eslint-config-core-ts": "~2.2.0",
"@swc/core": "~1.3.59",
"@types/commander": "^2.12.2",
"@types/fs-extra": "~11.0.1",
"@types/inquirer": "^6.5.0",
"@types/jest": "~29.5.1",
"@types/lodash": "^4.14.149",
"@types/mock-fs": "~4.13.1",
"@types/node": "^13.11.1",
"@types/node-fetch": "^2.5.6",
"@types/progress": "^2.0.3",
eslint: "~7.32.0",
husky: "^8.0.0",
jest: "~29.5.0",
"memory-fs": "^0.5.0",
"mock-fs": "~5.2.0",
nodemon: "^2.0.3",
"ts-jest": "~29.1.0",
tsup: "~6.7.0",
typescript: "~5.0.4"
},
directories: {
test: "tests"
},
repository: {
type: "git",
url: "git+https://github.com/infinum/js-polyglot-cli.git"
},
homepage: "https://github.com/infinum/js-polyglot-cli#readme",
jest: {
clearMocks: true,
coveragePathIgnorePatterns: [
"/tests/",
"/node_modules/"
],
moduleFileExtensions: [
"ts",
"js"
],
testRegex: "tests/(.*).ts$",
transform: {
"^.+\\.ts$": [
"ts-jest",
{
diagnostics: {
warnOnly: true
}
}
]
},
preset: "ts-jest",
testMatch: null
}
};
// src/state/index.ts
import * as path from "path";
// src/services/network.ts
import { PureModel } from "@datx/core";
import { config, jsonapiModel, modelToJsonApi } from "@datx/jsonapi";
import fetch from "node-fetch";
// src/constants/app.ts
var BASE_URL = "https://infinum.polyglothq.com";
var BASE_PATH = "/api/v2/";
// src/utils/log.ts
import colors from "colors/safe";
import { program } from "commander";
var log_default = {
log: function log() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var _console;
(_console = console).info.apply(_console, _to_consumable_array(args.map(function(arg) {
return colors.gray(arg);
})));
},
debug: function debug() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (process.env.NODE_ENV === "development") {
var _console;
(_console = console).info.apply(_console, _to_consumable_array(args.map(function(arg) {
return colors.blue(arg);
})));
}
},
info: function info() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (program.dryRun) {
var _console;
(_console = console).info.apply(_console, _to_consumable_array(args.map(function(arg) {
return colors.green(arg);
})));
}
},
error: function error() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var _console;
(_console = console).error.apply(_console, _to_consumable_array(args.map(function(arg) {
return colors.red(arg);
})));
return args[0];
}
};
// src/services/apify.ts
import { camelCase, isArray, isObject, map, mapKeys, mapValues, snakeCase } from "lodash";
function iterator(obj, transformer) {
if (isArray(obj)) {
return map(obj, function(value) {
return iterator(value, transformer);
});
} else if (isObject(obj)) {
var copy = mapValues(obj, function(value) {
return iterator(value, transformer);
});
return mapKeys(copy, function(_, key) {
return transformer(key);
});
}
return obj;
}
function apify(obj) {
return iterator(obj, snakeCase);
}
function deapify(obj) {
return iterator(obj, camelCase);
}
// src/services/network.ts
import { program as program2 } from "commander";
var DryRunModel = /*#__PURE__*/ function(_jsonapiModel) {
"use strict";
_inherits(DryRunModel, _jsonapiModel);
var _super = _create_super(DryRunModel);
function DryRunModel() {
_class_call_check(this, DryRunModel);
return _super.apply(this, arguments);
}
return DryRunModel;
}(jsonapiModel(PureModel));
DryRunModel.type = "base";
config.fetchReference = function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var _args_;
if (program2.dryRun && ((_args_ = args[1]) === null || _args_ === void 0 ? void 0 : _args_.method) !== "GET") {
return Promise.resolve({
status: 200,
json: function() {
return Promise.resolve({
data: modelToJsonApi(new DryRunModel())
});
}
});
}
return fetch.bind(fetch).apply(_this, _to_consumable_array(args));
};
config.defaultFetchOptions = {
credentials: "include"
};
config.baseUrl = "".concat(BASE_URL).concat(BASE_PATH);
config.defaultFetchOptions = {
headers: {
Accept: "application/vnd.api+json",
"Content-Type": "application/json"
}
};
config.transformResponse = function(opts) {
return _object_spread_props(_object_spread({}, opts), {
data: deapify(opts.data)
});
};
config.transformRequest = function(opts) {
var _appConfig_auth;
var store = opts.collection;
var appConfig = store.config;
opts.options = opts.options || {};
opts.options.networkConfig = opts.options.networkConfig || {};
opts.options.networkConfig.headers = {
"X-Auth-Token": ((_appConfig_auth = appConfig.auth) === null || _appConfig_auth === void 0 ? void 0 : _appConfig_auth.token) || ""
};
if (opts.method !== "GET") {
log_default.info(opts.method, opts.url);
}
log_default.debug(opts.method, opts.url);
return _object_spread_props(_object_spread({}, opts), {
data: apify(opts.data)
});
};
// src/state/models/Config.ts
import { jsonapi } from "@datx/jsonapi";
import { Model, Attribute } from "@datx/core";
// src/utils/file.ts
import * as fs from "fs";
import { merge } from "lodash";
import { program as program3 } from "commander";
function saveFile(path4, data) {
try {
log_default.debug("Saving to", path4);
if (program3.dryRun) {
log_default.info("Save file", path4);
} else {
fs.writeFileSync(path4, JSON.stringify(data, null, 2), "utf-8");
}
} catch (e) {
log_default.error(e);
process.exit(1);
}
}
function mergeFile(path4, data) {
var existing = readFile(path4);
saveFile(path4, merge({}, existing, data));
}
function requireFile(path4, defaultValue) {
return fs.existsSync(path4) ? __require(path4) : defaultValue;
}
function readFile(path4) {
if (fs.existsSync(path4)) {
try {
return JSON.parse(fs.readFileSync(path4, "utf-8"));
} catch (error) {
throw log_default.error("Error happened while parsing: ".concat(path4));
}
}
log_default.debug("File not found", path4);
return {};
}
function readDir(path4) {
if (fs.existsSync(path4)) {
return fs.readdirSync(path4, "utf-8");
}
log_default.debug("Folder not found", path4);
return [];
}
function unlinkFile(path4) {
if (fs.existsSync(path4)) {
fs.unlinkSync(path4);
}
}
// src/state/models/Config.ts
var Config = /*#__PURE__*/ function(_jsonapi) {
"use strict";
_inherits(Config, _jsonapi);
var _super = _create_super(Config);
function Config() {
_class_call_check(this, Config);
return _super.apply(this, arguments);
}
_create_class(Config, [
{
key: "loadAuth",
value: function loadAuth() {
var token = process.env.POLYGLOT_AUTH_TOKEN;
var defaultValue = token && {
token: token
};
this.auth = requireFile(this.authFile, defaultValue);
}
},
{
key: "loadProjectsConfig",
value: function loadProjectsConfig() {
try {
this.projectsConfig = requireFile(this.projectsConfigFile, {});
} catch (error) {
log_default.error("Projects config file is corrupted!");
process.exit(1);
}
}
},
{
key: "saveProjectsConfig",
value: function saveProjectsConfig() {
this.projectsConfig.version = this.version;
saveFile(this.projectsConfigFile, this.projectsConfig);
}
}
]);
return Config;
}(jsonapi(Model));
Config.type = "__config";
__decorateClass([
Attribute()
], Config.prototype, "version", 2);
__decorateClass([
Attribute()
], Config.prototype, "auth", 2);
__decorateClass([
Attribute()
], Config.prototype, "authFile", 2);
__decorateClass([
Attribute()
], Config.prototype, "projectsConfigFile", 2);
__decorateClass([
Attribute({
defaultValue: false
})
], Config.prototype, "debug", 2);
__decorateClass([
Attribute()
], Config.prototype, "projectsConfig", 2);
// src/state/models/Language.ts
import { jsonapi as jsonapi2 } from "@datx/jsonapi";
import { Model as Model2, Attribute as Attribute2, getModelId, getModelType } from "@datx/core";
var Language = /*#__PURE__*/ function(_jsonapi2) {
"use strict";
_inherits(Language, _jsonapi2);
var _super = _create_super(Language);
function Language() {
_class_call_check(this, Language);
return _super.apply(this, arguments);
}
_create_class(Language, [
{
key: "parsedLocale",
get: function get() {
var _this_meta_collection;
var config2 = (_this_meta_collection = this.meta.collection) === null || _this_meta_collection === void 0 ? void 0 : _this_meta_collection.config;
var options = Object.assign({
language: true,
country: true,
languageCodeSeparator: "_",
lowerCaseLanguageCode: false
}, config2 === null || config2 === void 0 ? void 0 : config2.projectsConfig.locale);
var locale = this.locale;
if (options.lowerCaseLanguageCode) {
locale = locale.toLowerCase();
}
if (options.language && options.country) {
return locale.replace("_", options.languageCodeSeparator);
}
var _locale_split = _sliced_to_array(locale.split("_"), 2), language = _locale_split[0], country = _locale_split[1];
return options.language ? language : country;
}
},
{
key: "display",
value: function display() {
return {
// [DatX error] meta not working
id: getModelId(this),
type: getModelType(this),
locale: this.locale
};
}
}
]);
return Language;
}(jsonapi2(Model2));
Language.type = "languages";
__decorateClass([
Attribute2()
], Language.prototype, "locale", 2);
__decorateClass([
Attribute2()
], Language.prototype, "name", 2);
__decorateClass([
Attribute2()
], Language.prototype, "localName", 2);
__decorateClass([
Attribute2()
], Language.prototype, "createdAt", 2);
__decorateClass([
Attribute2()
], Language.prototype, "updatedAt", 2);
__decorateClass([
Attribute2({
toMany: "translations",
referenceProperty: "language"
})
], Language.prototype, "translations", 2);
// src/state/models/Project.ts
import { jsonapi as jsonapi3 } from "@datx/jsonapi";
import { Model as Model3, Attribute as Attribute3, getModelId as getModelId2, getModelType as getModelType2 } from "@datx/core";
var Project = /*#__PURE__*/ function(_jsonapi3) {
"use strict";
_inherits(Project, _jsonapi3);
var _super = _create_super(Project);
function Project() {
_class_call_check(this, Project);
return _super.apply(this, arguments);
}
_create_class(Project, [
{
key: "display",
value: function display() {
return {
id: getModelId2(this),
type: getModelType2(this),
name: this.name
};
}
}
]);
return Project;
}(jsonapi3(Model3));
Project.type = "projects";
__decorateClass([
Attribute3({
isIdentifier: true
})
], Project.prototype, "id", 2);
__decorateClass([
Attribute3()
], Project.prototype, "lastUpdatedAt", 2);
__decorateClass([
Attribute3()
], Project.prototype, "name", 2);
__decorateClass([
Attribute3({
toOne: Language
})
], Project.prototype, "defaultLanguage", 2);
__decorateClass([
Attribute3()
], Project.prototype, "description", 2);
__decorateClass([
Attribute3()
], Project.prototype, "createdAt", 2);
__decorateClass([
Attribute3()
], Project.prototype, "updatedAt", 2);
__decorateClass([
Attribute3({
toMany: Language
})
], Project.prototype, "languages", 2);
// src/state/models/Session.ts
import { jsonapi as jsonapi4 } from "@datx/jsonapi";
import { Model as Model4, Attribute as Attribute4 } from "@datx/core";
var Session = /*#__PURE__*/ function(_jsonapi4) {
"use strict";
_inherits(Session, _jsonapi4);
var _super = _create_super(Session);
function Session() {
_class_call_check(this, Session);
return _super.apply(this, arguments);
}
return Session;
}(jsonapi4(Model4));
Session.type = "session";
Session.endpoint = "sessions";
__decorateClass([
Attribute4()
], Session.prototype, "token", 2);
__decorateClass([
Attribute4()
], Session.prototype, "email", 2);
// src/state/models/Translation.ts
import { jsonapi as jsonapi6 } from "@datx/jsonapi";
import { Model as Model6, Attribute as Attribute6, getModelId as getModelId4, getModelType as getModelType4 } from "@datx/core";
// src/state/models/TranslationKey.ts
import { jsonapi as jsonapi5 } from "@datx/jsonapi";
import { Model as Model5, Attribute as Attribute5, getModelId as getModelId3, getModelType as getModelType3 } from "@datx/core";
var TranslationKey = /*#__PURE__*/ function(_jsonapi5) {
"use strict";
_inherits(TranslationKey, _jsonapi5);
var _super = _create_super(TranslationKey);
function TranslationKey() {
_class_call_check(this, TranslationKey);
return _super.apply(this, arguments);
}
_create_class(TranslationKey, [
{
key: "save",
value: function save() {
var _this = this;
var _this1 = this, _superprop_get_save = function() {
return _get(_get_prototype_of(TranslationKey.prototype), "save", _this);
};
return _async_to_generator(function() {
return _ts_generator(this, function(_state) {
if (_this1.name !== _this1.localName && _this1.localName) {
log_default.info("Saving key: ".concat(_this1.name));
log_default.debug("save", _this1.name, _this1.localName);
_this1.name = _this1.localName;
return [
2,
_superprop_get_save().call(_this1)
];
}
return [
2,
_this1
];
});
})();
}
},
{
key: "display",
value: function display() {
return {
id: getModelId3(this),
type: getModelType3(this),
name: this.name
};
}
}
]);
return TranslationKey;
}(jsonapi5(Model5));
TranslationKey.type = "translation_keys";
__decorateClass([
Attribute5()
], TranslationKey.prototype, "name", 2);
__decorateClass([
Attribute5()
], TranslationKey.prototype, "localName", 2);
__decorateClass([
Attribute5({
defaultValue: null
})
], TranslationKey.prototype, "context", 2);
__decorateClass([
Attribute5({
toOne: function() {
return Project;
}
})
], TranslationKey.prototype, "project", 2);
__decorateClass([
Attribute5({
toMany: function() {
return Translation;
}
})
], TranslationKey.prototype, "translations", 2);
// src/state/models/Translation.ts
var Translation = /*#__PURE__*/ function(_jsonapi6) {
"use strict";
_inherits(Translation, _jsonapi6);
var _super = _create_super(Translation);
function Translation() {
_class_call_check(this, Translation);
return _super.apply(this, arguments);
}
_create_class(Translation, [
{
key: "save",
value: function save() {
var _this = this;
var _this1 = this, _superprop_get_save = function() {
return _get(_get_prototype_of(Translation.prototype), "save", _this);
};
return _async_to_generator(function() {
return _ts_generator(this, function(_state) {
if (_this1.value !== _this1.localValue && _this1.localValue) {
log_default.info('Saving translation "'.concat(_this1.value, '" -> "').concat(_this1.localValue, '"; key: "').concat(_this1.translationKey.name, '"; language: "').concat(_this1.language.locale, '"'));
log_default.debug("save translation", _this1.translationKey.name, _this1.value, _this1.localValue, _this1.meta.id);
_this1.value = _this1.localValue;
return [
2,
_superprop_get_save().call(_this1)
];
}
return [
2,
_this1
];
});
})();
}
},
{
key: "display",
value: function display() {
return {
id: getModelId4(this),
type: getModelType4(this),
value: this.value,
language: this.language.locale,
key: this.translationKey.name
};
}
}
]);
return Translation;
}(jsonapi6(Model6));
Translation.type = "translations";
__decorateClass([
Attribute6({
toOne: Language
})
], Translation.prototype, "language", 2);
__decorateClass([
Attribute6({
toOne: TranslationKey
})
], Translation.prototype, "translationKey", 2);
__decorateClass([
Attribute6()
], Translation.prototype, "value", 2);
__decorateClass([
Attribute6()
], Translation.prototype, "localValue", 2);
// src/state/index.ts
var AppData = /*#__PURE__*/ function(_jsonapi7) {
"use strict";
_inherits(AppData, _jsonapi7);
var _super = _create_super(AppData);
function AppData() {
_class_call_check(this, AppData);
var _this;
_this = _super.call(this);
var config2 = _this.add({
authFile: path.join(homedir() || "", ".polyglot.auth.json"),
projectsConfigFile: path.join(process.cwd(), ".polyglot.json"),
debug: process.env.NODE_ENV === "development",
version: package_default.version
}, Config);
config2.loadAuth();
config2.loadProjectsConfig();
return _this;
}
_create_class(AppData, [
{
key: "config",
get: function get() {
return this.findAll(Config)[0];
}
},
{
key: "getOneModel",
value: function getOneModel(type, id) {
var _this = this;
return _async_to_generator(function() {
var response;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
return [
4,
_this.getOne(type, id)
];
case 1:
response = _state.sent();
if (response.data) {
return [
2,
response.data
];
}
throw response;
}
});
})();
}
},
{
key: "getModels",
value: function getModels(type, options, tick) {
var _this = this;
return _async_to_generator(function() {
var _response_meta, _response_meta1, response, models, _models, _response_meta2, _response_meta3;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
return [
4,
_this.getMany(type, options)
];
case 1:
response = _state.sent();
models = _to_consumable_array(response.data);
tick === null || tick === void 0 ? void 0 : tick(response === null || response === void 0 ? void 0 : (_response_meta = response.meta) === null || _response_meta === void 0 ? void 0 : _response_meta["currentPage"], response === null || response === void 0 ? void 0 : (_response_meta1 = response.meta) === null || _response_meta1 === void 0 ? void 0 : _response_meta1["totalPages"]);
_state.label = 2;
case 2:
if (!("next" in response && response.next)) return [
3,
4
];
return [
4,
response.next()
];
case 3:
response = _state.sent();
(_models = models).push.apply(_models, _to_consumable_array(response.data));
tick === null || tick === void 0 ? void 0 : tick(response === null || response === void 0 ? void 0 : (_response_meta2 = response.meta) === null || _response_meta2 === void 0 ? void 0 : _response_meta2["currentPage"], response === null || response === void 0 ? void 0 : (_response_meta3 = response.meta) === null || _response_meta3 === void 0 ? void 0 : _response_meta3["totalPages"]);
return [
3,
2
];
case 4:
return [
2,
models
];
}
});
})();
}
},
{
key: "getModelByProject",
value: function getModelByProject(type, projectId, tick) {
var _this = this;
return _async_to_generator(function() {
return _ts_generator(this, function(_state) {
return [
2,
_this.getModels(type, {
queryParams: {
filter: {
project_id: projectId
},
custom: [
{
key: "page[size]",
value: "100"
}
]
}
}, tick)
];
});
})();
}
}
]);
return AppData;
}(jsonapi7(Collection));
AppData.types = [
Config,
Language,
Project,
Session,
Translation,
TranslationKey
];
var state_default = new AppData();
// src/commands/index.ts
var commands_exports = {};
__export(commands_exports, {
importCmd: function() {
return import_exports;
},
initCmd: function() {
return init_exports;
},
loginCmd: function() {
return login_exports;
},
logoutCmd: function() {
return logout_exports;
},
pullCmd: function() {
return pull_exports;
},
pushCmd: function() {
return push_exports;
},
statusCmd: function() {
return status_exports;
}
});
// src/commands/import.ts
var import_exports = {};
__export(import_exports, {
default: function() {
return import_default;
}
});
import { getModelId as getModelId5 } from "@datx/core";
import { mapValues as mapValues4 } from "lodash";
import * as path2 from "path";
// src/serializers/index.ts
import { mapValues as mapValues3 } from "lodash";
// src/serializers/structures/index.ts
var structures_exports = {};
__export(structures_exports, {
flat: function() {
return flat_exports;
},
nested: function() {
return nested_exports;
}
});
// src/serializers/structures/flat.ts
var flat_exports = {};
__export(flat_exports, {
forLocal: function() {
return forLocal;
},
forRemote: function() {
return forRemote;
}
});
function forLocal(data) {
return data;
}
function forRemote(data) {
return data;
}
// src/serializers/structures/nested.ts
var nested_exports = {};
__export(nested_exports, {
denestObject: function() {
return denestObject;
},
forLocal: function() {
return forLocal2;
},
forRemote: function() {
return forRemote2;
}
});
import { forEach, setWith, mapValues as mapValues2, isPlainObject } from "lodash";
function denestObject(data) {
var prefix = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
if (isPlainObject(data)) {
var _Object;
var copy = {};
var objects = [];
forEach(data, function(translations, key) {
if (isPlainObject(translations)) {
objects.push(denestObject(translations, "".concat(prefix).concat(key, ".")));
} else {
copy["".concat(prefix).concat(key)] = translations;
}
});
(_Object = Object).assign.apply(_Object, [
copy
].concat(_to_consumable_array(objects)));
return copy;
}
return data;
}
function forLocal2(data) {
var obj = {};
forEach(data, function(translations, locale) {
forEach(translations, function(translation, key) {
var path4 = [
locale
].concat(_to_consumable_array(key.split(/\./g)));
setWith(obj, path4, translation, Object);
});
});
return obj;
}
function forRemote2(data) {
return mapValues2(data, function(translations) {
return denestObject(translations);
});
}
// src/serializers/placeholders/index.ts
var placeholders_exports = {};
__export(placeholders_exports, {
harmony: function() {
return harmony_exports;
},
mustache: function() {
return mustache_exports;
}
});
// src/serializers/placeholders/harmony.ts
var harmony_exports = {};
__export(harmony_exports, {
forLocal: function() {
return forLocal3;
},
forRemote: function() {
return forRemote3;
}
});
var forLocal3 = function(translation) {
return translation.replace(/#\{([^}]+)\}/g, function(_, key) {
return "${".concat(key, "}");
});
};
var forRemote3 = function(translation) {
return translation.replace(/\$\{([^}]+)\}/g, function(_, key) {
return "#{".concat(key, "}");
});
};
// src/serializers/placeholders/mustache.ts
var mustache_exports = {};
__export(mustache_exports, {
forLocal: function() {
return forLocal4;
},
forRemote: function() {
return forRemote4;
}
});
var forLocal4 = function(translation) {
return translation.replace(/#\{([^}]+)\}/g, function(_, key) {
return "{{".concat(key, "}}");
});
};
var forRemote4 = function(translation) {
return translation.replace(/\{\{([^}]+)\}\}/g, function(_, key) {
return "#{".concat(key, "}");
});
};
// src/serializers/index.ts
function forLocal5(data, project) {
var transformed = mapValues3(data, function(language) {
var _project_placeholder;
return mapValues3(language, placeholders_exports[((_project_placeholder = project.placeholder) === null || _project_placeholder === void 0 ? void 0 : _project_placeholder.named) || "harmony" /* Harmony */ ].forLocal);
});
return structures_exports[project.serializer].forLocal(transformed);
}
function forRemote5(data, project) {
var transformed = structures_exports[project.serializer].forRemote(data);
return mapValues3(transformed, function(language) {
var _project_placeholder;
return mapValues3(language, placeholders_exports[((_project_placeholder = project.placeholder) === null || _project_placeholder === void 0 ? void 0 : _project_placeholder.named) || "harmony" /* Harmony */ ].forRemote);
});
}
// src/utils/validations.ts
function checkInitErrors() {
var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_user = _ref.user, user = _ref_user === void 0 ? true : _ref_user, _ref_project = _ref.project, project = _ref_project === void 0 ? true : _ref_project;
var _state_default_config_auth, _state_default_config_projectsConfig_projects;
if (user && !((_state_default_config_auth = state_default.config.auth) === null || _state_default_config_auth === void 0 ? void 0 : _state_default_config_auth.token)) {
throw log_default.error("You need to log in first");
}
if (project && (!state_default.config.projectsConfig || !((_state_default_config_projectsConfig_projects = state_default.config.projectsConfig.projects) === null || _state_default_config_projectsConfig_projects === void 0 ? void 0 : _state_default_config_projectsConfig_projects.length))) {
throw log_default.error("Please initialize the project first");
}
return null;
}
function checkPath(value) {
if (!value) {
return "The path is required";
} else if (value.startsWith("/")) {
return "The path should not be absolute";
}
return true;
}
function isMailRequired(value) {
return value ? true : "E-mail is required";
}
function logAPIErrors(e) {
e.map(function(error) {
if (error.status && error.title && error.detail) {
log_default.error("".concat(error.status, " ").concat(error.title, ": ").concat(error.detail));
} else {
log_default.error(error);
}
});
}
// src/utils/projects.ts
import { program as program4 } from "commander";
function getSelectedProjects() {
var selectedProjectId = program4.project;
if (!selectedProjectId) {
return state_default.config.projectsConfig.projects;
}
return state_default.config.projectsConfig.projects.filter(function(param) {
var id = param.id;
return id === selectedProjectId;
});
}
function getSavedProjects() {
return state_default.config.projectsConfig.projects || [];
}
// src/services/progress.ts
import ProgressBar from "progress";
import { sumBy } from "lodash";
var Progress = /*#__PURE__*/ function() {
"use strict";
function Progress() {
_class_call_check(this, Progress);
this.enabled = false;
this.items = [];
}
_create_class(Progress, [
{
key: "total",
get: function get() {
return sumBy(this.items, "count");
}
},
{
key: "setEnabled",
value: function setEnabled(enabled) {
this.enabled = enabled;
}
},
{
key: "setPlan",
value: function setPlan(items) {
this.items = items;
if (this.enabled) {
this.bar = new ProgressBar(":bar :stepName", {
total: 1e3,
width: 100,
clear: true
});
}
}
},
{
key: "tick",
value: function tick(key, current, total) {
if (this.bar) {
var currentItem = this.items.find(function(item) {
return item.key === key;
});
var curentIndex = currentItem ? this.items.indexOf(currentItem) : 0;
if (currentItem) {
currentItem.count = total || currentItem.count;
this.bar.curr = Math.round(1e3 * current / currentItem.count);
this.bar.render({
stepName: "".concat(currentItem.description, " (").concat(curentIndex + 1, "/").concat(this.items.length, ")")
});
}
}
}
},
{
key: "startWork",
value: function startWork(key) {
this.tick(key, 0);
}
}
]);
return Progress;
}();
var progress = new Progress();
function import_default(program6) {
return _import_default.apply(this, arguments);
}
function _import_default() {
_import_default = // src/commands/import.ts
_async_to_generator(function(program6) {
var cwd, selectedProjects, importFns, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, importFn, err;
var _arguments = arguments;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
cwd = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] :