polyglot-cli
Version:
Infinum Polyglot CLI
1,418 lines • 130 kB
JavaScript
#!/usr/bin/env node
"use strict";
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 __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = function(target, all) {
for(var name in all)__defProp(target, name, {
get: all[name],
enumerable: true
});
};
var __copyProps = function(to, from, except, desc) {
if (from && typeof from === "object" || typeof from === "function") {
var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
try {
var _loop = function() {
var key = _step.value;
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
get: function() {
return from[key];
},
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
};
for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally{
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
return to;
};
var __toESM = function(mod, isNodeMode, target) {
return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod);
};
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
var import_commander5 = __toESM(require("commander"));
var import_jsonapi9 = require("@datx/jsonapi");
// src/state/index.ts
var import_core8 = require("@datx/core");
var import_jsonapi8 = require("@datx/jsonapi");
var import_os = require("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
var path = __toESM(require("path"));
// src/services/network.ts
var import_core = require("@datx/core");
var import_jsonapi = require("@datx/jsonapi");
var import_node_fetch = __toESM(require("node-fetch"));
// src/constants/app.ts
var BASE_URL = "https://infinum.polyglothq.com";
var BASE_PATH = "/api/v2/";
// src/utils/log.ts
var import_safe = __toESM(require("colors/safe"));
var import_commander = require("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 import_safe.default.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 import_safe.default.blue(arg);
})));
}
},
info: function info() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (import_commander.program.dryRun) {
var _console;
(_console = console).info.apply(_console, _to_consumable_array(args.map(function(arg) {
return import_safe.default.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 import_safe.default.red(arg);
})));
return args[0];
}
};
// src/services/apify.ts
var import_lodash = require("lodash");
function iterator(obj, transformer) {
if ((0, import_lodash.isArray)(obj)) {
return (0, import_lodash.map)(obj, function(value) {
return iterator(value, transformer);
});
} else if ((0, import_lodash.isObject)(obj)) {
var copy = (0, import_lodash.mapValues)(obj, function(value) {
return iterator(value, transformer);
});
return (0, import_lodash.mapKeys)(copy, function(_, key) {
return transformer(key);
});
}
return obj;
}
function apify(obj) {
return iterator(obj, import_lodash.snakeCase);
}
function deapify(obj) {
return iterator(obj, import_lodash.camelCase);
}
// src/services/network.ts
var import_commander2 = require("commander");
var DryRunModel = /*#__PURE__*/ function(_superClass) {
_inherits(DryRunModel, _superClass);
var _super = _create_super(DryRunModel);
function DryRunModel() {
_class_call_check(this, DryRunModel);
return _super.apply(this, arguments);
}
return DryRunModel;
}((0, import_jsonapi.jsonapiModel)(import_core.PureModel));
DryRunModel.type = "base";
import_jsonapi.config.fetchReference = function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var _args_;
if (import_commander2.program.dryRun && ((_args_ = args[1]) === null || _args_ === void 0 ? void 0 : _args_.method) !== "GET") {
return Promise.resolve({
status: 200,
json: function() {
return Promise.resolve({
data: (0, import_jsonapi.modelToJsonApi)(new DryRunModel())
});
}
});
}
return import_node_fetch.default.bind(import_node_fetch.default).apply(_this, _to_consumable_array(args));
};
import_jsonapi.config.defaultFetchOptions = {
credentials: "include"
};
import_jsonapi.config.baseUrl = "".concat(BASE_URL).concat(BASE_PATH);
import_jsonapi.config.defaultFetchOptions = {
headers: {
Accept: "application/vnd.api+json",
"Content-Type": "application/json"
}
};
import_jsonapi.config.transformResponse = function(opts) {
return _object_spread_props(_object_spread({}, opts), {
data: deapify(opts.data)
});
};
import_jsonapi.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
var import_jsonapi2 = require("@datx/jsonapi");
var import_core2 = require("@datx/core");
// src/utils/file.ts
var fs = __toESM(require("fs"));
var import_lodash2 = require("lodash");
var import_commander3 = require("commander");
function saveFile(path4, data) {
try {
log_default.debug("Saving to", path4);
if (import_commander3.program.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, (0, import_lodash2.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(_superClass) {
_inherits(Config, _superClass);
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;
}((0, import_jsonapi2.jsonapi)(import_core2.Model));
Config.type = "__config";
__decorateClass([
(0, import_core2.Attribute)()
], Config.prototype, "version", 2);
__decorateClass([
(0, import_core2.Attribute)()
], Config.prototype, "auth", 2);
__decorateClass([
(0, import_core2.Attribute)()
], Config.prototype, "authFile", 2);
__decorateClass([
(0, import_core2.Attribute)()
], Config.prototype, "projectsConfigFile", 2);
__decorateClass([
(0, import_core2.Attribute)({
defaultValue: false
})
], Config.prototype, "debug", 2);
__decorateClass([
(0, import_core2.Attribute)()
], Config.prototype, "projectsConfig", 2);
// src/state/models/Language.ts
var import_jsonapi3 = require("@datx/jsonapi");
var import_core3 = require("@datx/core");
var Language = /*#__PURE__*/ function(_superClass) {
_inherits(Language, _superClass);
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: (0, import_core3.getModelId)(this),
type: (0, import_core3.getModelType)(this),
locale: this.locale
};
}
}
]);
return Language;
}((0, import_jsonapi3.jsonapi)(import_core3.Model));
Language.type = "languages";
__decorateClass([
(0, import_core3.Attribute)()
], Language.prototype, "locale", 2);
__decorateClass([
(0, import_core3.Attribute)()
], Language.prototype, "name", 2);
__decorateClass([
(0, import_core3.Attribute)()
], Language.prototype, "localName", 2);
__decorateClass([
(0, import_core3.Attribute)()
], Language.prototype, "createdAt", 2);
__decorateClass([
(0, import_core3.Attribute)()
], Language.prototype, "updatedAt", 2);
__decorateClass([
(0, import_core3.Attribute)({
toMany: "translations",
referenceProperty: "language"
})
], Language.prototype, "translations", 2);
// src/state/models/Project.ts
var import_jsonapi4 = require("@datx/jsonapi");
var import_core4 = require("@datx/core");
var Project = /*#__PURE__*/ function(_superClass) {
_inherits(Project, _superClass);
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: (0, import_core4.getModelId)(this),
type: (0, import_core4.getModelType)(this),
name: this.name
};
}
}
]);
return Project;
}((0, import_jsonapi4.jsonapi)(import_core4.Model));
Project.type = "projects";
__decorateClass([
(0, import_core4.Attribute)({
isIdentifier: true
})
], Project.prototype, "id", 2);
__decorateClass([
(0, import_core4.Attribute)()
], Project.prototype, "lastUpdatedAt", 2);
__decorateClass([
(0, import_core4.Attribute)()
], Project.prototype, "name", 2);
__decorateClass([
(0, import_core4.Attribute)({
toOne: Language
})
], Project.prototype, "defaultLanguage", 2);
__decorateClass([
(0, import_core4.Attribute)()
], Project.prototype, "description", 2);
__decorateClass([
(0, import_core4.Attribute)()
], Project.prototype, "createdAt", 2);
__decorateClass([
(0, import_core4.Attribute)()
], Project.prototype, "updatedAt", 2);
__decorateClass([
(0, import_core4.Attribute)({
toMany: Language
})
], Project.prototype, "languages", 2);
// src/state/models/Session.ts
var import_jsonapi5 = require("@datx/jsonapi");
var import_core5 = require("@datx/core");
var Session = /*#__PURE__*/ function(_superClass) {
_inherits(Session, _superClass);
var _super = _create_super(Session);
function Session() {
_class_call_check(this, Session);
return _super.apply(this, arguments);
}
return Session;
}((0, import_jsonapi5.jsonapi)(import_core5.Model));
Session.type = "session";
Session.endpoint = "sessions";
__decorateClass([
(0, import_core5.Attribute)()
], Session.prototype, "token", 2);
__decorateClass([
(0, import_core5.Attribute)()
], Session.prototype, "email", 2);
// src/state/models/Translation.ts
var import_jsonapi7 = require("@datx/jsonapi");
var import_core7 = require("@datx/core");
// src/state/models/TranslationKey.ts
var import_jsonapi6 = require("@datx/jsonapi");
var import_core6 = require("@datx/core");
var TranslationKey = /*#__PURE__*/ function(_superClass) {
_inherits(TranslationKey, _superClass);
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: (0, import_core6.getModelId)(this),
type: (0, import_core6.getModelType)(this),
name: this.name
};
}
}
]);
return TranslationKey;
}((0, import_jsonapi6.jsonapi)(import_core6.Model));
TranslationKey.type = "translation_keys";
__decorateClass([
(0, import_core6.Attribute)()
], TranslationKey.prototype, "name", 2);
__decorateClass([
(0, import_core6.Attribute)()
], TranslationKey.prototype, "localName", 2);
__decorateClass([
(0, import_core6.Attribute)({
defaultValue: null
})
], TranslationKey.prototype, "context", 2);
__decorateClass([
(0, import_core6.Attribute)({
toOne: function() {
return Project;
}
})
], TranslationKey.prototype, "project", 2);
__decorateClass([
(0, import_core6.Attribute)({
toMany: function() {
return Translation;
}
})
], TranslationKey.prototype, "translations", 2);
// src/state/models/Translation.ts
var Translation = /*#__PURE__*/ function(_superClass) {
_inherits(Translation, _superClass);
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: (0, import_core7.getModelId)(this),
type: (0, import_core7.getModelType)(this),
value: this.value,
language: this.language.locale,
key: this.translationKey.name
};
}
}
]);
return Translation;
}((0, import_jsonapi7.jsonapi)(import_core7.Model));
Translation.type = "translations";
__decorateClass([
(0, import_core7.Attribute)({
toOne: Language
})
], Translation.prototype, "language", 2);
__decorateClass([
(0, import_core7.Attribute)({
toOne: TranslationKey
})
], Translation.prototype, "translationKey", 2);
__decorateClass([
(0, import_core7.Attribute)()
], Translation.prototype, "value", 2);
__decorateClass([
(0, import_core7.Attribute)()
], Translation.prototype, "localValue", 2);
// src/state/index.ts
var AppData = /*#__PURE__*/ function(_superClass) {
_inherits(AppData, _superClass);
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((0, import_os.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;
}((0, import_jsonapi8.jsonapi)(import_core8.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;
}
});
var import_core9 = require("@datx/core");
var import_lodash6 = require("lodash");
var path2 = __toESM(require("path"));
// src/serializers/index.ts
var import_lodash4 = require("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;
}
});
var import_lodash3 = require("lodash");
function denestObject(data) {
var prefix = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
if ((0, import_lodash3.isPlainObject)(data)) {
var _Object;
var copy = {};
var objects = [];
(0, import_lodash3.forEach)(data, function(translations, key) {
if ((0, import_lodash3.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 = {};
(0, import_lodash3.forEach)(data, function(translations, locale) {
(0, import_lodash3.forEach)(translations, function(translation, key) {
var path4 = [
locale
].concat(_to_consumable_array(key.split(/\./g)));
(0, import_lodash3.setWith)(obj, path4, translation, Object);
});
});
return obj;
}
function forRemote2(data) {
return (0, import_lodash3.mapValues)(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 = (0, import_lodash4.mapValues)(data, function(language) {
var _project_placeholder;
return (0, import_lodash4.mapValues)(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 (0, import_lodash4.mapValues)(transformed, function(language) {
var _project_placeholder;
return (0, import_lodash4.mapValues)(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
var import_commander4 = require("commander");
function getSelectedProjects() {
var selectedProjectId = import_commander4.program.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
var import