@signageos/lib-ci 23.8.1 → 23.8.2

package/dist/ChangeLogEntry.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ChangeLogEntry_exports = {};
+__export(ChangeLogEntry_exports, {
+  ChangeLogEntry: () => ChangeLogEntry,
+  allChangelogEntries: () => allChangelogEntries,
+  isValidChangeLogEntry: () => isValidChangeLogEntry
+});
+module.exports = __toCommonJS(ChangeLogEntry_exports);
+var ChangeLogEntry = /* @__PURE__ */ ((ChangeLogEntry2) => {
+  ChangeLogEntry2["Changed"] = "Changed";
+  ChangeLogEntry2["Removed"] = "Removed";
+  ChangeLogEntry2["Added"] = "Added";
+  ChangeLogEntry2["Fixed"] = "Fixed";
+  ChangeLogEntry2["Security"] = "Security";
+  ChangeLogEntry2["Deprecated"] = "Deprecated";
+  return ChangeLogEntry2;
+})(ChangeLogEntry || {});
+const isValidChangeLogEntry = (x) => !!ChangeLogEntry[x];
+const allChangelogEntries = Object.values(ChangeLogEntry);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChangeLogEntry,
+  allChangelogEntries,
+  isValidChangeLogEntry
+});

package/dist/check-deps.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_semver = __toESM(require("semver"));
+var import_utils = require("./utils.js");
+(() => __async(exports, null, function* () {
+  const packagePath = process.cwd() + "/package.json";
+  const pkg = yield (0, import_utils.readJSON)(packagePath);
+  const ignorePath = process.cwd() + "/.check-depsignore";
+  let ignore = [];
+  try {
+    ignore = yield (0, import_utils.readJSON)(ignorePath);
+    console.log(`Ignoring packages from ${ignorePath}`);
+  } catch (_error) {
+    console.log("No ignore file found");
+  }
+  const runControlPath = process.cwd() + "/.check-depsrc.json";
+  let runControl;
+  try {
+    runControl = yield (0, import_utils.readJSON)(runControlPath);
+    console.log(`Using run control from ${runControlPath}`);
+    if (runControl.ignores) {
+      ignore = ignore.concat(runControl.ignores);
+    }
+  } catch (error) {
+    console.log("No Run Control file found");
+  }
+  const includeRegExp = new RegExp(process.argv[2] || ".+");
+  const excludeRegExp = new RegExp(process.argv[3] || "^$");
+  const deps = __spreadValues(__spreadValues({}, pkg.dependencies || {}), pkg.devDependencies || {});
+  const depNames = Object.keys(deps);
+  const matchedDepNames = depNames.filter((depName) => includeRegExp.test(depName) && !excludeRegExp.test(depName));
+  const prereleaseDepNames = [];
+  const inexactDepNames = [];
+  const expectedRangeDepNames = [];
+  function isExpectedRangeValid(depName, version) {
+    return version.startsWith(runControl == null ? void 0 : runControl.expectRanges[depName]);
+  }
+  for (const depName of matchedDepNames) {
+    if (ignore.includes(depName)) {
+      continue;
+    }
+    const depVersion = deps[depName];
+    const minVersion = import_semver.default.minVersion(depVersion);
+    if (!minVersion) {
+      throw new Error(`Invalid depversion ${depVersion}`);
+    }
+    if (import_semver.default.prerelease(minVersion) !== null) {
+      prereleaseDepNames.push(depName);
+    }
+    if ((runControl == null ? void 0 : runControl.expectRanges) && depName in runControl.expectRanges) {
+      if (!isExpectedRangeValid(depName, depVersion)) {
+        expectedRangeDepNames.push(depName);
+      }
+    } else {
+      if (!import_semver.default.valid(depVersion)) {
+        inexactDepNames.push(depName);
+      }
+    }
+  }
+  if (prereleaseDepNames.length > 0) {
+    const prereleaseDeps = {};
+    prereleaseDepNames.forEach((depName) => {
+      prereleaseDeps[depName] = deps[depName];
+    });
+    console.error(`Some packages has prerelease tags in version in package.json deps`, prereleaseDepNames.join(", "), prereleaseDeps);
+  }
+  if (expectedRangeDepNames.length > 0) {
+    const expectedRangeDeps = {};
+    expectedRangeDepNames.forEach((depName) => {
+      expectedRangeDeps[depName] = deps[depName];
+    });
+    console.error(
+      `Some packages has expectation of range of versions specified in package.json deps`,
+      expectedRangeDepNames.map((depName) => `${depName}->"${runControl == null ? void 0 : runControl.expectRanges[depName]}"`).join(", "),
+      expectedRangeDeps
+    );
+  }
+  if (inexactDepNames.length > 0) {
+    const inexactDeps = {};
+    inexactDepNames.forEach((depName) => {
+      inexactDeps[depName] = deps[depName];
+    });
+    console.error(`Some packages has not exact version specified in package.json deps`, inexactDepNames.join(", "), inexactDeps);
+  }
+  if (prereleaseDepNames.length > 0 || expectedRangeDepNames.length > 0 || inexactDepNames.length > 0) {
+    process.exit(1);
+  }
+}))();

package/dist/check-forbidden-dependencies.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+"use strict";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_utils = require("./utils.js");
+(() => __async(exports, null, function* () {
+  const packagePath = process.cwd() + "/package.json";
+  const pkg = yield (0, import_utils.readJSON)(packagePath);
+  const dependencies = pkg.dependencies || {};
+  const devDependencies = pkg.devDependencies || {};
+  const whitelist = ["@signageos/codestyle"];
+  const packages = Object.keys(dependencies).concat(Object.keys(devDependencies));
+  let forbiddenPackages = packages.filter((p) => p.match("@signageos/*"));
+  forbiddenPackages = forbiddenPackages.filter((p) => !whitelist.includes(p));
+  if (forbiddenPackages.length > 0) {
+    console.error(`    Forbidden packages ${forbiddenPackages.join(", ")} found in package.json. 
+@signageos/* modules can't be used as dependencies because they are private while this module is public and may only use public dependencies.
+Only exceptions are whitelisted dependencies: ${whitelist.join(", ")}
+`);
+    process.exit(1);
+  }
+}))();

package/dist/detect-semver-level.js

@@ -0,0 +1,54 @@
+"use strict";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_ChangeLogEntry = require("./ChangeLogEntry");
+var import_helper = require("./helper");
+(function() {
+  return __async(this, null, function* () {
+    const changeLog = yield (0, import_helper.getPipedInput)();
+    const groupedLog = (0, import_helper.getGroupedChangeLog)(changeLog);
+    const changedTypes = Object.keys(groupedLog.Unreleased || {});
+    switch (true) {
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Changed) !== -1:
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Removed) !== -1:
+        process.stdout.write("major");
+        break;
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Added) !== -1:
+        process.stdout.write("minor");
+        break;
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Fixed) !== -1:
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Security) !== -1:
+      case changedTypes.indexOf(import_ChangeLogEntry.ChangeLogEntry.Deprecated) !== -1:
+        process.stdout.write("patch");
+        break;
+      case changedTypes.length === 0:
+        process.stdout.write("patch");
+        break;
+      default:
+        throw new Error(
+          `Unknown type of change: ${changedTypes.join(", ")} Only following values are allowed: ${import_ChangeLogEntry.allChangelogEntries.join(", ")}`
+        );
+    }
+  });
+})();
+process.on("unhandledRejection", (error) => {
+  throw error;
+});

package/dist/exact-deps.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+"use strict";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_fs = require("fs");
+var import_helper = require("./helper");
+function exactDepsMutable(deps, lock) {
+  deps = deps || {};
+  const depNames = Object.keys(deps);
+  for (const depName of depNames) {
+    const lockDep = lock.dependencies[depName];
+    if (!lockDep) {
+      throw new Error("package-lock.json is outdated");
+    }
+    const currentVersion = lockDep.version;
+    deps[depName] = currentVersion;
+  }
+}
+(() => __async(exports, null, function* () {
+  const packagePath = process.cwd() + "/package.json";
+  const packageLockPath = process.cwd() + "/package-lock.json";
+  const pkg = yield (0, import_helper.readJSON)(packagePath);
+  const packageLock = yield (0, import_helper.readJSON)(packageLockPath);
+  exactDepsMutable(pkg.dependencies, packageLock);
+  exactDepsMutable(pkg.devDependencies, packageLock);
+  const indentChar = yield (0, import_helper.detectIndent)(packagePath);
+  yield import_fs.promises.writeFile(packagePath, JSON.stringify(pkg, void 0, indentChar) + "\n");
+}))();

package/dist/get-release-log.js

@@ -0,0 +1,48 @@
+"use strict";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_helper = require("./helper");
+const version = process.argv[2] || "Unreleased";
+const outputType = process.argv[3] || "text";
+(function() {
+  return __async(this, null, function* () {
+    const changeLog = yield (0, import_helper.getPipedInput)();
+    const groupedLog = (0, import_helper.getGroupedChangeLog)(changeLog);
+    let output;
+    if (outputType === "text") {
+      const changedTypes = Object.keys(groupedLog[version] || {});
+      const releaseNotes = changedTypes.reduce(
+        (notes, changeType) => {
+          var _a, _b, _c;
+          return [...notes, `${changeType}:`, ...(_c = (_b = (_a = groupedLog[version]) == null ? void 0 : _a[changeType]) == null ? void 0 : _b.map((note) => `- ${note}`)) != null ? _c : [], ""];
+        },
+        []
+      );
+      output = releaseNotes.join("\n");
+    } else if (outputType === "groups") {
+      output = typeof groupedLog[version] !== "undefined" ? groupedLog[version] : {};
+    }
+    process.stdout.write(JSON.stringify(output));
+  });
+})();
+process.on("unhandledRejection", (error) => {
+  throw error;
+});

package/dist/helper.js

@@ -0,0 +1,154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var helper_exports = {};
+__export(helper_exports, {
+  detectIndent: () => detectIndent,
+  detectIndentInString: () => detectIndentInString,
+  getGroupedChangeLog: () => getGroupedChangeLog,
+  getPipedInput: () => getPipedInput,
+  readJSON: () => readJSON
+});
+module.exports = __toCommonJS(helper_exports);
+var import_ChangeLogEntry = require("./ChangeLogEntry");
+var import_fs = require("fs");
+const VERSION_HEADER = "## ";
+const CHANGES_HEADER = "### ";
+const LOG_LINE = "- ";
+const getPipedInput = function() {
+  return new Promise((resolve, reject) => {
+    let inputData;
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => inputData += chunk);
+    process.stdin.on("end", () => resolve(inputData));
+    process.stdin.on("error", (error) => reject(error));
+  });
+};
+const getGroupedChangeLog = function(changeLog) {
+  const newLines = changeLog.split(/\n|\r/).map((line) => line.trim()).filter((line) => line.startsWith(VERSION_HEADER) || line.startsWith(CHANGES_HEADER) || line.startsWith(LOG_LINE));
+  const { groupedLog } = newLines.reduce(
+    (reduction, line) => {
+      var _a, _b;
+      if (line.startsWith(VERSION_HEADER)) {
+        const version = (_b = (_a = line.substring(VERSION_HEADER.length).match(/^\[?(([\d\w\.\-\+])+)\]?/)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim();
+        if (version === void 0) {
+          throw new Error(`Invalid version format "${version}"`);
+        }
+        if (reduction.groupedLog[version] !== void 0) {
+          throw new Error(`The version "${version}" is duplicated in CHANGELOG`);
+        }
+        return __spreadProps(__spreadValues({}, reduction), {
+          lastVersion: version,
+          groupedLog: __spreadProps(__spreadValues({}, reduction.groupedLog), {
+            [version]: {}
+          })
+        });
+      } else if (line.startsWith(CHANGES_HEADER)) {
+        const type = line.substring(CHANGES_HEADER.length).trim();
+        const versionGroup = reduction.groupedLog[reduction.lastVersion];
+        if (versionGroup === void 0 || reduction.lastVersion === null) {
+          throw new Error(`The type "${type}" is not under any version section in CHANGELOG`);
+        }
+        if (!(0, import_ChangeLogEntry.isValidChangeLogEntry)(type)) {
+          throw new Error(`Invalid type entry ${type}`);
+        }
+        if (versionGroup[type] !== void 0) {
+          throw new Error(`The type "${type}" is duplicated at version "${reduction.lastVersion}" in CHANGELOG`);
+        }
+        return __spreadProps(__spreadValues({}, reduction), {
+          lastType: type,
+          groupedLog: __spreadProps(__spreadValues({}, reduction.groupedLog), {
+            [reduction.lastVersion]: __spreadProps(__spreadValues({}, reduction.groupedLog[reduction.lastVersion]), {
+              [type]: versionGroup[type] || []
+            })
+          })
+        });
+      } else {
+        if (reduction.lastVersion === null) {
+          throw new Error(`Line "${line}" is not under any version section in CHANGELOG`);
+        }
+        if (reduction.lastType === null) {
+          throw new Error(`Line "${line}" is not under any type section in CHANGELOG`);
+        }
+        return __spreadProps(__spreadValues({}, reduction), {
+          groupedLog: __spreadProps(__spreadValues({}, reduction.groupedLog), {
+            [reduction.lastVersion]: __spreadProps(__spreadValues({}, reduction.groupedLog[reduction.lastVersion]), {
+              [reduction.lastType]: [
+                ...reduction.groupedLog[reduction.lastVersion][reduction.lastType],
+                line.substring(LOG_LINE.length)
+              ]
+            })
+          })
+        });
+      }
+    },
+    { groupedLog: {}, lastType: null, lastVersion: null }
+  );
+  return groupedLog;
+};
+const readJSON = (path) => import_fs.promises.readFile(path).then((b) => JSON.parse(b.toString()));
+const detectIndent = (path) => __async(void 0, null, function* () {
+  return yield import_fs.promises.readFile(path).then((b) => b.toString()).then(detectIndentInString);
+});
+const detectIndentInString = (str) => /^\t/m.test(str) ? "	" : "  ";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectIndent,
+  detectIndentInString,
+  getGroupedChangeLog,
+  getPipedInput,
+  readJSON
+});

package/dist/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  readJSON: () => readJSON,
+  transformFile: () => transformFile
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = require("fs");
+const readJSON = (path) => import_fs.promises.readFile(path).then((b) => JSON.parse(b.toString()));
+const transformFile = (path, map) => import_fs.promises.readFile(path).then((b) => b.toString()).then(map).then((contents) => import_fs.promises.writeFile(path, contents));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readJSON,
+  transformFile
+});

package/dist/version-upgrade.js

@@ -0,0 +1,45 @@
+"use strict";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import_fs = require("fs");
+var import_helper = require("./helper");
+(() => __async(exports, null, function* () {
+  const packagePath = process.cwd() + "/package.json";
+  const packageLockPath = process.cwd() + "/package-lock.json";
+  const pkg = yield (0, import_helper.readJSON)(packagePath);
+  const packageLock = yield (0, import_helper.readJSON)(packageLockPath).catch(() => null);
+  const nextVersion = process.argv[2];
+  if (!nextVersion) {
+    throw new Error("No version specified");
+  }
+  pkg.version = nextVersion;
+  if (packageLock) {
+    packageLock.version = nextVersion;
+    if (packageLock.packages && packageLock.packages[""]) {
+      packageLock.packages[""].version = nextVersion;
+    }
+  }
+  const indentChar = yield (0, import_helper.detectIndent)(packagePath);
+  yield import_fs.promises.writeFile(packagePath, JSON.stringify(pkg, null, indentChar) + "\n");
+  if (packageLock) {
+    yield import_fs.promises.writeFile(packageLockPath, JSON.stringify(packageLock, null, indentChar) + "\n");
+  }
+}))();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@signageos/lib-ci",
-	"version": "23.8.1",
+	"version": "23.8.2",
 	"main": "dist/bin.js",
 	"author": "",
 	"license": "ISC",
@@ -32,10 +32,11 @@
 	"dependencies": {},
 	"files": [
 		"tools",
+		"dist",
 		"package.json"
 	],
 	"publishConfig": {
-		"registry": "https://registry.npmjs.org/",
+		"registry": "https://registry.npmjs.com/",
 		"access": "public"
 	}
 }