@uipath/packager-tool-datafabric 1.204.0-preview.250 → 1.204.0-preview.255

package/dist/THIRD-PARTY-NOTICES.md

@@ -5,7 +5,7 @@ compiled into its `dist/` output rather than installed alongside it.
 Their licences and copyright notices are reproduced here in full, as
 those licences require.
 
-16 bundled dependencies:
+17 bundled dependencies:
 
 - @uipath/entity-modeler@1.12.1 — SEE LICENSE IN LICENSE.txt
 - bundle-name@4.1.0 — MIT
@@ -13,6 +13,7 @@ those licences require.
 - default-browser@5.5.0 — MIT
 - default-browser-id@5.0.1 — MIT
 - define-lazy-prop@3.0.0 — MIT
+- ignore@5.3.2 — MIT
 - is-docker@3.0.0 — MIT
 - is-in-ssh@1.0.0 — MIT
 - is-inside-container@1.0.0 — MIT
@@ -141,6 +142,36 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ---
 
+## ignore@5.3.2
+
+SPDX: MIT
+
+```
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
 ## is-docker@3.0.0
 
 SPDX: MIT

package/dist/init.js

@@ -7382,6 +7382,266 @@ var require_commander = __commonJS(function(exports) {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// ../../../node_modules/ignore/index.js
+var require_ignore = __commonJS(function(exports, module) {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define = (object, key, value) => Object.defineProperty(object, key, { value });
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str2) => index + 6 < str2.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ],
+    [
+      /(\^|\\\/)?\\\*$/,
+      (_, p1) => {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    ]
+  ];
+  var regexCache = Object.create(null);
+  var makeRegex = (pattern, ignoreCase) => {
+    let source = regexCache[pattern];
+    if (!source) {
+      source = REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+      regexCache[pattern] = source;
+    }
+    return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+  };
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+
+  class IgnoreRule {
+    constructor(origin, pattern, negative, regex) {
+      this.origin = origin;
+      this.pattern = pattern;
+      this.negative = negative;
+      this.regex = regex;
+    }
+  }
+  var createRule = (pattern, ignoreCase) => {
+    const origin = pattern;
+    let negative = false;
+    if (pattern.indexOf("!") === 0) {
+      negative = true;
+      pattern = pattern.substr(1);
+    }
+    pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regex = makeRegex(pattern, ignoreCase);
+    return new IgnoreRule(origin, pattern, negative, regex);
+  };
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path3, originalPath, doThrow) => {
+    if (!isString(path3)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path3) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path3)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path3) => REGEX_TEST_INVALID_PATH.test(path3);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define(this, KEY_IGNORE, true);
+      this._rules = [];
+      this._ignoreCase = ignoreCase;
+      this._allowRelativePaths = allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    _addPattern(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules);
+        this._added = true;
+        return;
+      }
+      if (checkPattern(pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this);
+      if (this._added) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _testOne(path3, checkUnignored) {
+      let ignored = false;
+      let unignored = false;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule.regex.test(path3);
+        if (matched) {
+          ignored = !negative;
+          unignored = negative;
+        }
+      });
+      return {
+        ignored,
+        unignored
+      };
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path3 = originalPath && checkPath.convert(originalPath);
+      checkPath(path3, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path3, cache, checkUnignored, slices);
+    }
+    _t(path3, cache, checkUnignored, slices) {
+      if (path3 in cache) {
+        return cache[path3];
+      }
+      if (!slices) {
+        slices = path3.split(SLASH);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path3] = this._testOne(path3, checkUnignored);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path3] = parent.ignored ? parent : this._testOne(path3, checkUnignored);
+    }
+    ignores(path3) {
+      return this._test(path3, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path3) => !this.ignores(path3);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path3) {
+      return this._test(path3, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path3) => checkPath(path3 && checkPath.convert(path3), path3, RETURN_FALSE);
+  factory.isPathValid = isPathValid;
+  factory.default = factory;
+  module.exports = factory;
+  if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
+    const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path3) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path3) || isNotRelative(path3);
+  }
+});
+
 // ../../filesystem/src/node.ts
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
@@ -11904,7 +12164,7 @@ var package_default = {
   name: "@uipath/solution-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0-preview.250",
+  version: "1.204.0-preview.255",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -11960,6 +12220,7 @@ var package_default = {
     "@uipath/studioweb-sdk": "workspace:*",
     "@types/node": "^25.5.2",
     fflate: "^0.8.2",
+    ignore: "^5.3.2",
     typescript: "^7.0.2"
   }
 };
@@ -12571,6 +12832,7 @@ function buildOptedOutInstructions(projectDir) {
 var API_PROJECT_TYPES = new Set(["api", "apiautomation"]);
 
 // ../../solution-sdk/src/zip-utils.ts
+var import_ignore = __toESM(require_ignore(), 1);
 var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
   ".venv",
   "node_modules",
@@ -12831,4 +13093,4 @@ export {
   entityInitAsync
 };
 
-//# debugId=A739AB2B8727319364756E2164756E21
+//# debugId=8DC460C7B137A4CD64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-datafabric",
-    "version": "1.204.0-preview.250",
+    "version": "1.204.0-preview.255",
     "description": "UiPath Data Fabric entity schema, validation and packaging library",
     "type": "module",
     "exports": {
@@ -24,5 +24,5 @@
     "peerDependencies": {
         "@uipath/solutionpackager-tool-core": "1.204.0"
     },
-    "gitHead": "80ffb08b3e58d7ca233b16fae8521163b1dcd635"
+    "gitHead": "699c58dabb59414557755a8933bcbe40aa420df3"
 }