@verbb/plugin-kit-react 1.0.0

package/dist/node_modules/jexl/dist/parser/Parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/parser/Parser.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar handlers = require('./handlers');\n\nvar states = require('./states').states;\n/**\n * The Parser is a state machine that converts tokens from the {@link Lexer}\n * into an Abstract Syntax Tree (AST), capable of being evaluated in any\n * context by the {@link Evaluator}.  The Parser expects that all tokens\n * provided to it are legal and typed properly according to the grammar, but\n * accepts that the tokens may still be in an invalid order or in some other\n * unparsable configuration that requires it to throw an Error.\n * @param {{}} grammar The grammar object to use to parse Jexl strings\n * @param {string} [prefix] A string prefix to prepend to the expression string\n *      for error messaging purposes.  This is useful for when a new Parser is\n *      instantiated to parse an subexpression, as the parent Parser's\n *      expression string thus far can be passed for a more user-friendly\n *      error message.\n * @param {{}} [stopMap] A mapping of token types to any truthy value. When the\n *      token type is encountered, the parser will return the mapped value\n *      instead of boolean false.\n */\n\n\nvar Parser = /*#__PURE__*/function () {\n  function Parser(grammar, prefix, stopMap) {\n    (0, _classCallCheck2.default)(this, Parser);\n    this._grammar = grammar;\n    this._state = 'expectOperand';\n    this._tree = null;\n    this._exprStr = prefix || '';\n    this._relative = false;\n    this._stopMap = stopMap || {};\n  }\n  /**\n   * Processes a new token into the AST and manages the transitions of the state\n   * machine.\n   * @param {{type: <string>}} token A token object, as provided by the\n   *      {@link Lexer#tokenize} function.\n   * @throws {Error} if a token is added when the Parser has been marked as\n   *      complete by {@link #complete}, or if an unexpected token type is added.\n   * @returns {boolean|*} the stopState value if this parser encountered a token\n   *      in the stopState mapb false if tokens can continue.\n   */\n\n\n  (0, _createClass2.default)(Parser, [{\n    key: \"addToken\",\n    value: function addToken(token) {\n      if (this._state === 'complete') {\n        throw new Error('Cannot add a new token to a completed Parser');\n      }\n\n      var state = states[this._state];\n      var startExpr = this._exprStr;\n      this._exprStr += token.raw;\n\n      if (state.subHandler) {\n        if (!this._subParser) {\n          this._startSubExpression(startExpr);\n        }\n\n        var stopState = this._subParser.addToken(token);\n\n        if (stopState) {\n          this._endSubExpression();\n\n          if (this._parentStop) return stopState;\n          this._state = stopState;\n        }\n      } else if (state.tokenTypes[token.type]) {\n        var typeOpts = state.tokenTypes[token.type];\n        var handleFunc = handlers[token.type];\n\n        if (typeOpts.handler) {\n          handleFunc = typeOpts.handler;\n        }\n\n        if (handleFunc) {\n          handleFunc.call(this, token);\n        }\n\n        if (typeOpts.toState) {\n          this._state = typeOpts.toState;\n        }\n      } else if (this._stopMap[token.type]) {\n        return this._stopMap[token.type];\n      } else {\n        throw new Error(\"Token \".concat(token.raw, \" (\").concat(token.type, \") unexpected in expression: \").concat(this._exprStr));\n      }\n\n      return false;\n    }\n    /**\n     * Processes an array of tokens iteratively through the {@link #addToken}\n     * function.\n     * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by\n     *      the {@link Lexer#tokenize} function.\n     */\n\n  }, {\n    key: \"addTokens\",\n    value: function addTokens(tokens) {\n      tokens.forEach(this.addToken, this);\n    }\n    /**\n     * Marks this Parser instance as completed and retrieves the full AST.\n     * @returns {{}|null} a full expression tree, ready for evaluation by the\n     *      {@link Evaluator#eval} function, or null if no tokens were passed to\n     *      the parser before complete was called\n     * @throws {Error} if the parser is not in a state where it's legal to end\n     *      the expression, indicating that the expression is incomplete\n     */\n\n  }, {\n    key: \"complete\",\n    value: function complete() {\n      if (this._cursor && !states[this._state].completable) {\n        throw new Error(\"Unexpected end of expression: \".concat(this._exprStr));\n      }\n\n      if (this._subParser) {\n        this._endSubExpression();\n      }\n\n      this._state = 'complete';\n      return this._cursor ? this._tree : null;\n    }\n    /**\n     * Indicates whether the expression tree contains a relative path identifier.\n     * @returns {boolean} true if a relative identifier exists false otherwise.\n     */\n\n  }, {\n    key: \"isRelative\",\n    value: function isRelative() {\n      return this._relative;\n    }\n    /**\n     * Ends a subexpression by completing the subParser and passing its result\n     * to the subHandler configured in the current state.\n     * @private\n     */\n\n  }, {\n    key: \"_endSubExpression\",\n    value: function _endSubExpression() {\n      states[this._state].subHandler.call(this, this._subParser.complete());\n\n      this._subParser = null;\n    }\n    /**\n     * Places a new tree node at the current position of the cursor (to the 'right'\n     * property) and then advances the cursor to the new node. This function also\n     * handles setting the parent of the new node.\n     * @param {{type: <string>}} node A node to be added to the AST\n     * @private\n     */\n\n  }, {\n    key: \"_placeAtCursor\",\n    value: function _placeAtCursor(node) {\n      if (!this._cursor) {\n        this._tree = node;\n      } else {\n        this._cursor.right = node;\n\n        this._setParent(node, this._cursor);\n      }\n\n      this._cursor = node;\n    }\n    /**\n     * Places a tree node before the current position of the cursor, replacing\n     * the node that the cursor currently points to. This should only be called in\n     * cases where the cursor is known to exist, and the provided node already\n     * contains a pointer to what's at the cursor currently.\n     * @param {{type: <string>}} node A node to be added to the AST\n     * @private\n     */\n\n  }, {\n    key: \"_placeBeforeCursor\",\n    value: function _placeBeforeCursor(node) {\n      this._cursor = this._cursor._parent;\n\n      this._placeAtCursor(node);\n    }\n    /**\n     * Sets the parent of a node by creating a non-enumerable _parent property\n     * that points to the supplied parent argument.\n     * @param {{type: <string>}} node A node of the AST on which to set a new\n     *      parent\n     * @param {{type: <string>}} parent An existing node of the AST to serve as the\n     *      parent of the new node\n     * @private\n     */\n\n  }, {\n    key: \"_setParent\",\n    value: function _setParent(node, parent) {\n      Object.defineProperty(node, '_parent', {\n        value: parent,\n        writable: true\n      });\n    }\n    /**\n     * Prepares the Parser to accept a subexpression by (re)instantiating the\n     * subParser.\n     * @param {string} [exprStr] The expression string to prefix to the new Parser\n     * @private\n     */\n\n  }, {\n    key: \"_startSubExpression\",\n    value: function _startSubExpression(exprStr) {\n      var endStates = states[this._state].endStates;\n\n      if (!endStates) {\n        this._parentStop = true;\n        endStates = this._stopMap;\n      }\n\n      this._subParser = new Parser(this._grammar, exprStr, endStates);\n    }\n  }]);\n  return Parser;\n}();\n\nmodule.exports = Parser;"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/jexl/dist/parser/handlers.js

@@ -0,0 +1,205 @@
+import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
+//#region ../node_modules/jexl/dist/parser/handlers.js
+var require_handlers = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Handles a subexpression that's used to define a transform argument's value.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.argVal = function(ast) {
+		if (ast) this._cursor.args.push(ast);
+	};
+	/**
+	* Handles new array literals by adding them as a new node in the AST,
+	* initialized with an empty array.
+	*/
+	exports.arrayStart = function() {
+		this._placeAtCursor({
+			type: "ArrayLiteral",
+			value: []
+		});
+	};
+	/**
+	* Handles a subexpression representing an element of an array literal.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.arrayVal = function(ast) {
+		if (ast) this._cursor.value.push(ast);
+	};
+	/**
+	* Handles tokens of type 'binaryOp', indicating an operation that has two
+	* inputs: a left side and a right side.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.binaryOp = function(token) {
+		var precedence = this._grammar.elements[token.value].precedence || 0;
+		var parent = this._cursor._parent;
+		while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {
+			this._cursor = parent;
+			parent = parent._parent;
+		}
+		var node = {
+			type: "BinaryExpression",
+			operator: token.value,
+			left: this._cursor
+		};
+		this._setParent(this._cursor, node);
+		this._cursor = parent;
+		this._placeAtCursor(node);
+	};
+	/**
+	* Handles successive nodes in an identifier chain.  More specifically, it
+	* sets values that determine how the following identifier gets placed in the
+	* AST.
+	*/
+	exports.dot = function() {
+		this._nextIdentEncapsulate = this._cursor && this._cursor.type !== "UnaryExpression" && (this._cursor.type !== "BinaryExpression" || this._cursor.type === "BinaryExpression" && this._cursor.right);
+		this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;
+		if (this._nextIdentRelative) this._relative = true;
+	};
+	/**
+	* Handles a subexpression used for filtering an array returned by an
+	* identifier chain.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.filter = function(ast) {
+		this._placeBeforeCursor({
+			type: "FilterExpression",
+			expr: ast,
+			relative: this._subParser.isRelative(),
+			subject: this._cursor
+		});
+	};
+	/**
+	* Handles identifier tokens when used to indicate the name of a function to
+	* be called.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.functionCall = function() {
+		this._placeBeforeCursor({
+			type: "FunctionCall",
+			name: this._cursor.value,
+			args: [],
+			pool: "functions"
+		});
+	};
+	/**
+	* Handles identifier tokens by adding them as a new node in the AST.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.identifier = function(token) {
+		var node = {
+			type: "Identifier",
+			value: token.value
+		};
+		if (this._nextIdentEncapsulate) {
+			node.from = this._cursor;
+			this._placeBeforeCursor(node);
+			this._nextIdentEncapsulate = false;
+		} else {
+			if (this._nextIdentRelative) {
+				node.relative = true;
+				this._nextIdentRelative = false;
+			}
+			this._placeAtCursor(node);
+		}
+	};
+	/**
+	* Handles literal values, such as strings, booleans, and numerics, by adding
+	* them as a new node in the AST.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.literal = function(token) {
+		this._placeAtCursor({
+			type: "Literal",
+			value: token.value
+		});
+	};
+	/**
+	* Queues a new object literal key to be written once a value is collected.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.objKey = function(token) {
+		this._curObjKey = token.value;
+	};
+	/**
+	* Handles new object literals by adding them as a new node in the AST,
+	* initialized with an empty object.
+	*/
+	exports.objStart = function() {
+		this._placeAtCursor({
+			type: "ObjectLiteral",
+			value: {}
+		});
+	};
+	/**
+	* Handles an object value by adding its AST to the queued key on the object
+	* literal node currently at the cursor.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.objVal = function(ast) {
+		this._cursor.value[this._curObjKey] = ast;
+	};
+	/**
+	* Handles traditional subexpressions, delineated with the groupStart and
+	* groupEnd elements.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.subExpression = function(ast) {
+		this._placeAtCursor(ast);
+	};
+	/**
+	* Handles a completed alternate subexpression of a ternary operator.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.ternaryEnd = function(ast) {
+		this._cursor.alternate = ast;
+	};
+	/**
+	* Handles a completed consequent subexpression of a ternary operator.
+	* @param {{type: <string>}} ast The subexpression tree
+	*/
+	exports.ternaryMid = function(ast) {
+		this._cursor.consequent = ast;
+	};
+	/**
+	* Handles the start of a new ternary expression by encapsulating the entire
+	* AST in a ConditionalExpression node, and using the existing tree as the
+	* test element.
+	*/
+	exports.ternaryStart = function() {
+		this._tree = {
+			type: "ConditionalExpression",
+			test: this._tree
+		};
+		this._cursor = this._tree;
+	};
+	/**
+	* Handles identifier tokens when used to indicate the name of a transform to
+	* be applied.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.transform = function(token) {
+		this._placeBeforeCursor({
+			type: "FunctionCall",
+			name: token.value,
+			args: [this._cursor],
+			pool: "transforms"
+		});
+	};
+	/**
+	* Handles token of type 'unaryOp', indicating that the operation has only
+	* one input: a right side.
+	* @param {{type: <string>}} token A token object
+	*/
+	exports.unaryOp = function(token) {
+		this._placeAtCursor({
+			type: "UnaryExpression",
+			operator: token.value
+		});
+	};
+}));
+//#endregion
+export default require_handlers();
+export { require_handlers };
+
+//# sourceMappingURL=handlers.js.map

package/dist/node_modules/jexl/dist/parser/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/parser/handlers.js"],"sourcesContent":["\"use strict\";\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\n\n/**\n * Handles a subexpression that's used to define a transform argument's value.\n * @param {{type: <string>}} ast The subexpression tree\n */\nexports.argVal = function (ast) {\n  if (ast) this._cursor.args.push(ast);\n};\n/**\n * Handles new array literals by adding them as a new node in the AST,\n * initialized with an empty array.\n */\n\n\nexports.arrayStart = function () {\n  this._placeAtCursor({\n    type: 'ArrayLiteral',\n    value: []\n  });\n};\n/**\n * Handles a subexpression representing an element of an array literal.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.arrayVal = function (ast) {\n  if (ast) {\n    this._cursor.value.push(ast);\n  }\n};\n/**\n * Handles tokens of type 'binaryOp', indicating an operation that has two\n * inputs: a left side and a right side.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.binaryOp = function (token) {\n  var precedence = this._grammar.elements[token.value].precedence || 0;\n  var parent = this._cursor._parent;\n\n  while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {\n    this._cursor = parent;\n    parent = parent._parent;\n  }\n\n  var node = {\n    type: 'BinaryExpression',\n    operator: token.value,\n    left: this._cursor\n  };\n\n  this._setParent(this._cursor, node);\n\n  this._cursor = parent;\n\n  this._placeAtCursor(node);\n};\n/**\n * Handles successive nodes in an identifier chain.  More specifically, it\n * sets values that determine how the following identifier gets placed in the\n * AST.\n */\n\n\nexports.dot = function () {\n  this._nextIdentEncapsulate = this._cursor && this._cursor.type !== 'UnaryExpression' && (this._cursor.type !== 'BinaryExpression' || this._cursor.type === 'BinaryExpression' && this._cursor.right);\n  this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;\n\n  if (this._nextIdentRelative) {\n    this._relative = true;\n  }\n};\n/**\n * Handles a subexpression used for filtering an array returned by an\n * identifier chain.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.filter = function (ast) {\n  this._placeBeforeCursor({\n    type: 'FilterExpression',\n    expr: ast,\n    relative: this._subParser.isRelative(),\n    subject: this._cursor\n  });\n};\n/**\n * Handles identifier tokens when used to indicate the name of a function to\n * be called.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.functionCall = function () {\n  this._placeBeforeCursor({\n    type: 'FunctionCall',\n    name: this._cursor.value,\n    args: [],\n    pool: 'functions'\n  });\n};\n/**\n * Handles identifier tokens by adding them as a new node in the AST.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.identifier = function (token) {\n  var node = {\n    type: 'Identifier',\n    value: token.value\n  };\n\n  if (this._nextIdentEncapsulate) {\n    node.from = this._cursor;\n\n    this._placeBeforeCursor(node);\n\n    this._nextIdentEncapsulate = false;\n  } else {\n    if (this._nextIdentRelative) {\n      node.relative = true;\n      this._nextIdentRelative = false;\n    }\n\n    this._placeAtCursor(node);\n  }\n};\n/**\n * Handles literal values, such as strings, booleans, and numerics, by adding\n * them as a new node in the AST.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.literal = function (token) {\n  this._placeAtCursor({\n    type: 'Literal',\n    value: token.value\n  });\n};\n/**\n * Queues a new object literal key to be written once a value is collected.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.objKey = function (token) {\n  this._curObjKey = token.value;\n};\n/**\n * Handles new object literals by adding them as a new node in the AST,\n * initialized with an empty object.\n */\n\n\nexports.objStart = function () {\n  this._placeAtCursor({\n    type: 'ObjectLiteral',\n    value: {}\n  });\n};\n/**\n * Handles an object value by adding its AST to the queued key on the object\n * literal node currently at the cursor.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.objVal = function (ast) {\n  this._cursor.value[this._curObjKey] = ast;\n};\n/**\n * Handles traditional subexpressions, delineated with the groupStart and\n * groupEnd elements.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.subExpression = function (ast) {\n  this._placeAtCursor(ast);\n};\n/**\n * Handles a completed alternate subexpression of a ternary operator.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.ternaryEnd = function (ast) {\n  this._cursor.alternate = ast;\n};\n/**\n * Handles a completed consequent subexpression of a ternary operator.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.ternaryMid = function (ast) {\n  this._cursor.consequent = ast;\n};\n/**\n * Handles the start of a new ternary expression by encapsulating the entire\n * AST in a ConditionalExpression node, and using the existing tree as the\n * test element.\n */\n\n\nexports.ternaryStart = function () {\n  this._tree = {\n    type: 'ConditionalExpression',\n    test: this._tree\n  };\n  this._cursor = this._tree;\n};\n/**\n * Handles identifier tokens when used to indicate the name of a transform to\n * be applied.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.transform = function (token) {\n  this._placeBeforeCursor({\n    type: 'FunctionCall',\n    name: token.value,\n    args: [this._cursor],\n    pool: 'transforms'\n  });\n};\n/**\n * Handles token of type 'unaryOp', indicating that the operation has only\n * one input: a right side.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.unaryOp = function (token) {\n  this._placeAtCursor({\n    type: 'UnaryExpression',\n    operator: token.value\n  });\n};"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAWA,SAAQ,SAAS,SAAU,KAAK;AAC9B,MAAI,IAAK,MAAK,QAAQ,KAAK,KAAK,IAAI;;;;;;AAQtC,SAAQ,aAAa,WAAY;AAC/B,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,EAAE;GACV,CAAC;;;;;;AAQJ,SAAQ,WAAW,SAAU,KAAK;AAChC,MAAI,IACF,MAAK,QAAQ,MAAM,KAAK,IAAI;;;;;;;AAUhC,SAAQ,WAAW,SAAU,OAAO;EAClC,IAAI,aAAa,KAAK,SAAS,SAAS,MAAM,OAAO,cAAc;EACnE,IAAI,SAAS,KAAK,QAAQ;AAE1B,SAAO,UAAU,OAAO,YAAY,KAAK,SAAS,SAAS,OAAO,UAAU,cAAc,YAAY;AACpG,QAAK,UAAU;AACf,YAAS,OAAO;;EAGlB,IAAI,OAAO;GACT,MAAM;GACN,UAAU,MAAM;GAChB,MAAM,KAAK;GACZ;AAED,OAAK,WAAW,KAAK,SAAS,KAAK;AAEnC,OAAK,UAAU;AAEf,OAAK,eAAe,KAAK;;;;;;;AAS3B,SAAQ,MAAM,WAAY;AACxB,OAAK,wBAAwB,KAAK,WAAW,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ;AAC9L,OAAK,qBAAqB,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC,KAAK;AAEjE,MAAI,KAAK,mBACP,MAAK,YAAY;;;;;;;AAUrB,SAAQ,SAAS,SAAU,KAAK;AAC9B,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM;GACN,UAAU,KAAK,WAAW,YAAY;GACtC,SAAS,KAAK;GACf,CAAC;;;;;;;AASJ,SAAQ,eAAe,WAAY;AACjC,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM,KAAK,QAAQ;GACnB,MAAM,EAAE;GACR,MAAM;GACP,CAAC;;;;;;AAQJ,SAAQ,aAAa,SAAU,OAAO;EACpC,IAAI,OAAO;GACT,MAAM;GACN,OAAO,MAAM;GACd;AAED,MAAI,KAAK,uBAAuB;AAC9B,QAAK,OAAO,KAAK;AAEjB,QAAK,mBAAmB,KAAK;AAE7B,QAAK,wBAAwB;SACxB;AACL,OAAI,KAAK,oBAAoB;AAC3B,SAAK,WAAW;AAChB,SAAK,qBAAqB;;AAG5B,QAAK,eAAe,KAAK;;;;;;;;AAU7B,SAAQ,UAAU,SAAU,OAAO;AACjC,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,MAAM;GACd,CAAC;;;;;;AAQJ,SAAQ,SAAS,SAAU,OAAO;AAChC,OAAK,aAAa,MAAM;;;;;;AAQ1B,SAAQ,WAAW,WAAY;AAC7B,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,EAAE;GACV,CAAC;;;;;;;AASJ,SAAQ,SAAS,SAAU,KAAK;AAC9B,OAAK,QAAQ,MAAM,KAAK,cAAc;;;;;;;AASxC,SAAQ,gBAAgB,SAAU,KAAK;AACrC,OAAK,eAAe,IAAI;;;;;;AAQ1B,SAAQ,aAAa,SAAU,KAAK;AAClC,OAAK,QAAQ,YAAY;;;;;;AAQ3B,SAAQ,aAAa,SAAU,KAAK;AAClC,OAAK,QAAQ,aAAa;;;;;;;AAS5B,SAAQ,eAAe,WAAY;AACjC,OAAK,QAAQ;GACX,MAAM;GACN,MAAM,KAAK;GACZ;AACD,OAAK,UAAU,KAAK;;;;;;;AAStB,SAAQ,YAAY,SAAU,OAAO;AACnC,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM,MAAM;GACZ,MAAM,CAAC,KAAK,QAAQ;GACpB,MAAM;GACP,CAAC;;;;;;;AASJ,SAAQ,UAAU,SAAU,OAAO;AACjC,OAAK,eAAe;GAClB,MAAM;GACN,UAAU,MAAM;GACjB,CAAC"}

package/dist/node_modules/jexl/dist/parser/states.js

@@ -0,0 +1,158 @@
+import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_handlers } from "./handlers.js";
+//#region ../node_modules/jexl/dist/parser/states.js
+var require_states = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var h = require_handlers();
+	/**
+	* A mapping of all states in the finite state machine to a set of instructions
+	* for handling or transitioning into other states. Each state can be handled
+	* in one of two schemes: a tokenType map, or a subHandler.
+	*
+	* Standard expression elements are handled through the tokenType object. This
+	* is an object map of all legal token types to encounter in this state (and
+	* any unexpected token types will generate a thrown error) to an options
+	* object that defines how they're handled.  The available options are:
+	*
+	*      {string} toState: The name of the state to which to transition
+	*          immediately after handling this token
+	*      {string} handler: The handler function to call when this token type is
+	*          encountered in this state.  If omitted, the default handler
+	*          matching the token's "type" property will be called. If the handler
+	*          function does not exist, no call will be made and no error will be
+	*          generated.  This is useful for tokens whose sole purpose is to
+	*          transition to other states.
+	*
+	* States that consume a subexpression should define a subHandler, the
+	* function to be called with an expression tree argument when the
+	* subexpression is complete. Completeness is determined through the
+	* endStates object, which maps tokens on which an expression should end to the
+	* state to which to transition once the subHandler function has been called.
+	*
+	* Additionally, any state in which it is legal to mark the AST as completed
+	* should have a 'completable' property set to boolean true.  Attempting to
+	* call {@link Parser#complete} in any state without this property will result
+	* in a thrown Error.
+	*
+	* @type {{}}
+	*/
+	exports.states = {
+		expectOperand: { tokenTypes: {
+			literal: { toState: "expectBinOp" },
+			identifier: { toState: "identifier" },
+			unaryOp: {},
+			openParen: { toState: "subExpression" },
+			openCurl: {
+				toState: "expectObjKey",
+				handler: h.objStart
+			},
+			dot: { toState: "traverse" },
+			openBracket: {
+				toState: "arrayVal",
+				handler: h.arrayStart
+			}
+		} },
+		expectBinOp: {
+			tokenTypes: {
+				binaryOp: { toState: "expectOperand" },
+				pipe: { toState: "expectTransform" },
+				dot: { toState: "traverse" },
+				question: {
+					toState: "ternaryMid",
+					handler: h.ternaryStart
+				}
+			},
+			completable: true
+		},
+		expectTransform: { tokenTypes: { identifier: {
+			toState: "postTransform",
+			handler: h.transform
+		} } },
+		expectObjKey: { tokenTypes: {
+			identifier: {
+				toState: "expectKeyValSep",
+				handler: h.objKey
+			},
+			closeCurl: { toState: "expectBinOp" }
+		} },
+		expectKeyValSep: { tokenTypes: { colon: { toState: "objVal" } } },
+		postTransform: {
+			tokenTypes: {
+				openParen: { toState: "argVal" },
+				binaryOp: { toState: "expectOperand" },
+				dot: { toState: "traverse" },
+				openBracket: { toState: "filter" },
+				pipe: { toState: "expectTransform" }
+			},
+			completable: true
+		},
+		postArgs: {
+			tokenTypes: {
+				binaryOp: { toState: "expectOperand" },
+				dot: { toState: "traverse" },
+				openBracket: { toState: "filter" },
+				pipe: { toState: "expectTransform" }
+			},
+			completable: true
+		},
+		identifier: {
+			tokenTypes: {
+				binaryOp: { toState: "expectOperand" },
+				dot: { toState: "traverse" },
+				openBracket: { toState: "filter" },
+				openParen: {
+					toState: "argVal",
+					handler: h.functionCall
+				},
+				pipe: { toState: "expectTransform" },
+				question: {
+					toState: "ternaryMid",
+					handler: h.ternaryStart
+				}
+			},
+			completable: true
+		},
+		traverse: { tokenTypes: { identifier: { toState: "identifier" } } },
+		filter: {
+			subHandler: h.filter,
+			endStates: { closeBracket: "identifier" }
+		},
+		subExpression: {
+			subHandler: h.subExpression,
+			endStates: { closeParen: "expectBinOp" }
+		},
+		argVal: {
+			subHandler: h.argVal,
+			endStates: {
+				comma: "argVal",
+				closeParen: "postArgs"
+			}
+		},
+		objVal: {
+			subHandler: h.objVal,
+			endStates: {
+				comma: "expectObjKey",
+				closeCurl: "expectBinOp"
+			}
+		},
+		arrayVal: {
+			subHandler: h.arrayVal,
+			endStates: {
+				comma: "arrayVal",
+				closeBracket: "expectBinOp"
+			}
+		},
+		ternaryMid: {
+			subHandler: h.ternaryMid,
+			endStates: { colon: "ternaryEnd" }
+		},
+		ternaryEnd: {
+			subHandler: h.ternaryEnd,
+			completable: true
+		}
+	};
+}));
+//#endregion
+export default require_states();
+export { require_states };
+
+//# sourceMappingURL=states.js.map

package/dist/node_modules/jexl/dist/parser/states.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"states.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/parser/states.js"],"sourcesContent":["\"use strict\";\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar h = require('./handlers');\n/**\n * A mapping of all states in the finite state machine to a set of instructions\n * for handling or transitioning into other states. Each state can be handled\n * in one of two schemes: a tokenType map, or a subHandler.\n *\n * Standard expression elements are handled through the tokenType object. This\n * is an object map of all legal token types to encounter in this state (and\n * any unexpected token types will generate a thrown error) to an options\n * object that defines how they're handled.  The available options are:\n *\n *      {string} toState: The name of the state to which to transition\n *          immediately after handling this token\n *      {string} handler: The handler function to call when this token type is\n *          encountered in this state.  If omitted, the default handler\n *          matching the token's \"type\" property will be called. If the handler\n *          function does not exist, no call will be made and no error will be\n *          generated.  This is useful for tokens whose sole purpose is to\n *          transition to other states.\n *\n * States that consume a subexpression should define a subHandler, the\n * function to be called with an expression tree argument when the\n * subexpression is complete. Completeness is determined through the\n * endStates object, which maps tokens on which an expression should end to the\n * state to which to transition once the subHandler function has been called.\n *\n * Additionally, any state in which it is legal to mark the AST as completed\n * should have a 'completable' property set to boolean true.  Attempting to\n * call {@link Parser#complete} in any state without this property will result\n * in a thrown Error.\n *\n * @type {{}}\n */\n\n\nexports.states = {\n  expectOperand: {\n    tokenTypes: {\n      literal: {\n        toState: 'expectBinOp'\n      },\n      identifier: {\n        toState: 'identifier'\n      },\n      unaryOp: {},\n      openParen: {\n        toState: 'subExpression'\n      },\n      openCurl: {\n        toState: 'expectObjKey',\n        handler: h.objStart\n      },\n      dot: {\n        toState: 'traverse'\n      },\n      openBracket: {\n        toState: 'arrayVal',\n        handler: h.arrayStart\n      }\n    }\n  },\n  expectBinOp: {\n    tokenTypes: {\n      binaryOp: {\n        toState: 'expectOperand'\n      },\n      pipe: {\n        toState: 'expectTransform'\n      },\n      dot: {\n        toState: 'traverse'\n      },\n      question: {\n        toState: 'ternaryMid',\n        handler: h.ternaryStart\n      }\n    },\n    completable: true\n  },\n  expectTransform: {\n    tokenTypes: {\n      identifier: {\n        toState: 'postTransform',\n        handler: h.transform\n      }\n    }\n  },\n  expectObjKey: {\n    tokenTypes: {\n      identifier: {\n        toState: 'expectKeyValSep',\n        handler: h.objKey\n      },\n      closeCurl: {\n        toState: 'expectBinOp'\n      }\n    }\n  },\n  expectKeyValSep: {\n    tokenTypes: {\n      colon: {\n        toState: 'objVal'\n      }\n    }\n  },\n  postTransform: {\n    tokenTypes: {\n      openParen: {\n        toState: 'argVal'\n      },\n      binaryOp: {\n        toState: 'expectOperand'\n      },\n      dot: {\n        toState: 'traverse'\n      },\n      openBracket: {\n        toState: 'filter'\n      },\n      pipe: {\n        toState: 'expectTransform'\n      }\n    },\n    completable: true\n  },\n  postArgs: {\n    tokenTypes: {\n      binaryOp: {\n        toState: 'expectOperand'\n      },\n      dot: {\n        toState: 'traverse'\n      },\n      openBracket: {\n        toState: 'filter'\n      },\n      pipe: {\n        toState: 'expectTransform'\n      }\n    },\n    completable: true\n  },\n  identifier: {\n    tokenTypes: {\n      binaryOp: {\n        toState: 'expectOperand'\n      },\n      dot: {\n        toState: 'traverse'\n      },\n      openBracket: {\n        toState: 'filter'\n      },\n      openParen: {\n        toState: 'argVal',\n        handler: h.functionCall\n      },\n      pipe: {\n        toState: 'expectTransform'\n      },\n      question: {\n        toState: 'ternaryMid',\n        handler: h.ternaryStart\n      }\n    },\n    completable: true\n  },\n  traverse: {\n    tokenTypes: {\n      identifier: {\n        toState: 'identifier'\n      }\n    }\n  },\n  filter: {\n    subHandler: h.filter,\n    endStates: {\n      closeBracket: 'identifier'\n    }\n  },\n  subExpression: {\n    subHandler: h.subExpression,\n    endStates: {\n      closeParen: 'expectBinOp'\n    }\n  },\n  argVal: {\n    subHandler: h.argVal,\n    endStates: {\n      comma: 'argVal',\n      closeParen: 'postArgs'\n    }\n  },\n  objVal: {\n    subHandler: h.objVal,\n    endStates: {\n      comma: 'expectObjKey',\n      closeCurl: 'expectBinOp'\n    }\n  },\n  arrayVal: {\n    subHandler: h.arrayVal,\n    endStates: {\n      comma: 'arrayVal',\n      closeBracket: 'expectBinOp'\n    }\n  },\n  ternaryMid: {\n    subHandler: h.ternaryMid,\n    endStates: {\n      colon: 'ternaryEnd'\n    }\n  },\n  ternaryEnd: {\n    subHandler: h.ternaryEnd,\n    completable: true\n  }\n};"],"x_google_ignoreList":[0],"mappings":";;;;CAMA,IAAI,IAAA,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCJ,SAAQ,SAAS;EACf,eAAe,EACb,YAAY;GACV,SAAS,EACP,SAAS,eACV;GACD,YAAY,EACV,SAAS,cACV;GACD,SAAS,EAAE;GACX,WAAW,EACT,SAAS,iBACV;GACD,UAAU;IACR,SAAS;IACT,SAAS,EAAE;IACZ;GACD,KAAK,EACH,SAAS,YACV;GACD,aAAa;IACX,SAAS;IACT,SAAS,EAAE;IACZ;GACF,EACF;EACD,aAAa;GACX,YAAY;IACV,UAAU,EACR,SAAS,iBACV;IACD,MAAM,EACJ,SAAS,mBACV;IACD,KAAK,EACH,SAAS,YACV;IACD,UAAU;KACR,SAAS;KACT,SAAS,EAAE;KACZ;IACF;GACD,aAAa;GACd;EACD,iBAAiB,EACf,YAAY,EACV,YAAY;GACV,SAAS;GACT,SAAS,EAAE;GACZ,EACF,EACF;EACD,cAAc,EACZ,YAAY;GACV,YAAY;IACV,SAAS;IACT,SAAS,EAAE;IACZ;GACD,WAAW,EACT,SAAS,eACV;GACF,EACF;EACD,iBAAiB,EACf,YAAY,EACV,OAAO,EACL,SAAS,UACV,EACF,EACF;EACD,eAAe;GACb,YAAY;IACV,WAAW,EACT,SAAS,UACV;IACD,UAAU,EACR,SAAS,iBACV;IACD,KAAK,EACH,SAAS,YACV;IACD,aAAa,EACX,SAAS,UACV;IACD,MAAM,EACJ,SAAS,mBACV;IACF;GACD,aAAa;GACd;EACD,UAAU;GACR,YAAY;IACV,UAAU,EACR,SAAS,iBACV;IACD,KAAK,EACH,SAAS,YACV;IACD,aAAa,EACX,SAAS,UACV;IACD,MAAM,EACJ,SAAS,mBACV;IACF;GACD,aAAa;GACd;EACD,YAAY;GACV,YAAY;IACV,UAAU,EACR,SAAS,iBACV;IACD,KAAK,EACH,SAAS,YACV;IACD,aAAa,EACX,SAAS,UACV;IACD,WAAW;KACT,SAAS;KACT,SAAS,EAAE;KACZ;IACD,MAAM,EACJ,SAAS,mBACV;IACD,UAAU;KACR,SAAS;KACT,SAAS,EAAE;KACZ;IACF;GACD,aAAa;GACd;EACD,UAAU,EACR,YAAY,EACV,YAAY,EACV,SAAS,cACV,EACF,EACF;EACD,QAAQ;GACN,YAAY,EAAE;GACd,WAAW,EACT,cAAc,cACf;GACF;EACD,eAAe;GACb,YAAY,EAAE;GACd,WAAW,EACT,YAAY,eACb;GACF;EACD,QAAQ;GACN,YAAY,EAAE;GACd,WAAW;IACT,OAAO;IACP,YAAY;IACb;GACF;EACD,QAAQ;GACN,YAAY,EAAE;GACd,WAAW;IACT,OAAO;IACP,WAAW;IACZ;GACF;EACD,UAAU;GACR,YAAY,EAAE;GACd,WAAW;IACT,OAAO;IACP,cAAc;IACf;GACF;EACD,YAAY;GACV,YAAY,EAAE;GACd,WAAW,EACT,OAAO,cACR;GACF;EACD,YAAY;GACV,YAAY,EAAE;GACd,aAAa;GACd;EACF"}

package/dist/types/global.d.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/utils/classes.d.ts

@@ -0,0 +1,18 @@
+import { ClassValue } from 'clsx';
+/**
+ * Utility function to merge class names with Tailwind support
+ *
+ * Combines clsx for conditional class names with tailwind-merge for
+ * proper handling of Tailwind utility classes.
+ *
+ * @param inputs - Class names or conditional class name objects to merge
+ * @returns Merged class name string with proper Tailwind handling
+ *
+ * @example
+ * ```ts
+ * cn('p-4', 'bg-red-500', { 'hidden': isHidden })
+ * // Returns: 'p-4 bg-red-500' or 'p-4 bg-red-500 hidden'
+ * ```
+ */
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=classes.d.ts.map

package/dist/utils/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../src/utils/classes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAG7C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/utils/classes.js

@@ -0,0 +1,25 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+//#region src/utils/classes.ts
+/**
+* Utility function to merge class names with Tailwind support
+*
+* Combines clsx for conditional class names with tailwind-merge for
+* proper handling of Tailwind utility classes.
+*
+* @param inputs - Class names or conditional class name objects to merge
+* @returns Merged class name string with proper Tailwind handling
+*
+* @example
+* ```ts
+* cn('p-4', 'bg-red-500', { 'hidden': isHidden })
+* // Returns: 'p-4 bg-red-500' or 'p-4 bg-red-500 hidden'
+* ```
+*/
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+//#endregion
+export { cn };
+
+//# sourceMappingURL=classes.js.map

package/dist/utils/classes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.js","names":[],"sources":["../../src/utils/classes.ts"],"sourcesContent":["import { clsx, type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\n/**\n * Utility function to merge class names with Tailwind support\n *\n * Combines clsx for conditional class names with tailwind-merge for\n * proper handling of Tailwind utility classes.\n *\n * @param inputs - Class names or conditional class name objects to merge\n * @returns Merged class name string with proper Tailwind handling\n *\n * @example\n * ```ts\n * cn('p-4', 'bg-red-500', { 'hidden': isHidden })\n * // Returns: 'p-4 bg-red-500' or 'p-4 bg-red-500 hidden'\n * ```\n */\nexport function cn(...inputs: ClassValue[]) {\n    return twMerge(clsx(inputs));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,GAAG,GAAG,QAAsB;AACxC,QAAO,QAAQ,KAAK,OAAO,CAAC"}

package/dist/utils/config.d.ts

@@ -0,0 +1,14 @@
+import { TranslateParams } from './translation';
+import { PluginKitReactHostBridge } from './hostBridge';
+type TranslateFunction = (category: string, message: string, params?: TranslateParams) => string;
+export type PluginKitReactConfig = {
+    portalClassName?: string;
+    portalContainer?: HTMLElement | ShadowRoot | null;
+    shadowRootSelectors?: string[];
+    translationCategory?: string;
+    translate?: TranslateFunction;
+    hostBridge?: Partial<PluginKitReactHostBridge>;
+};
+export declare const configurePluginKitReact: (config: PluginKitReactConfig) => void;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAgD,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAiB,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE5E,KAAK,iBAAiB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;AAEjG,MAAM,MAAM,oBAAoB,GAAG;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,IAAI,CAAC;IAClD,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,UAAU,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAClD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,oBAAoB,KAAG,IAwBtE,CAAC"}

package/dist/utils/config.js

@@ -0,0 +1,16 @@
+import { setPortalClassName, setPortalContainer, setShadowRootSelectors } from "./portal.js";
+import { setTranslateFunction, setTranslationCategory } from "./translation.js";
+import { setHostBridge } from "./hostBridge.js";
+//#region src/utils/config.ts
+var configurePluginKitReact = (config) => {
+	if (config.portalClassName) setPortalClassName(config.portalClassName);
+	if (config.portalContainer) setPortalContainer(config.portalContainer);
+	if (config.shadowRootSelectors) setShadowRootSelectors(config.shadowRootSelectors);
+	if (config.translationCategory) setTranslationCategory(config.translationCategory);
+	if (config.translate) setTranslateFunction(config.translate);
+	if (config.hostBridge) setHostBridge(config.hostBridge);
+};
+//#endregion
+export { configurePluginKitReact };
+
+//# sourceMappingURL=config.js.map

package/dist/utils/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../src/utils/config.ts"],"sourcesContent":["import { setPortalClassName, setPortalContainer, setShadowRootSelectors } from './portal';\nimport { setTranslationCategory, setTranslateFunction, type TranslateParams } from './translation';\nimport { setHostBridge, type PluginKitReactHostBridge } from './hostBridge';\n\ntype TranslateFunction = (category: string, message: string, params?: TranslateParams) => string;\n\nexport type PluginKitReactConfig = {\n    portalClassName?: string;\n    portalContainer?: HTMLElement | ShadowRoot | null;\n    shadowRootSelectors?: string[];\n    translationCategory?: string;\n    translate?: TranslateFunction;\n    hostBridge?: Partial<PluginKitReactHostBridge>;\n};\n\nexport const configurePluginKitReact = (config: PluginKitReactConfig): void => {\n    if (config.portalClassName) {\n        setPortalClassName(config.portalClassName);\n    }\n\n    if (config.portalContainer) {\n        setPortalContainer(config.portalContainer);\n    }\n\n    if (config.shadowRootSelectors) {\n        setShadowRootSelectors(config.shadowRootSelectors);\n    }\n\n    if (config.translationCategory) {\n        setTranslationCategory(config.translationCategory);\n    }\n\n    if (config.translate) {\n        setTranslateFunction(config.translate);\n    }\n\n    if (config.hostBridge) {\n        setHostBridge(config.hostBridge);\n    }\n};\n"],"mappings":";;;;AAeA,IAAa,2BAA2B,WAAuC;AAC3E,KAAI,OAAO,gBACP,oBAAmB,OAAO,gBAAgB;AAG9C,KAAI,OAAO,gBACP,oBAAmB,OAAO,gBAAgB;AAG9C,KAAI,OAAO,oBACP,wBAAuB,OAAO,oBAAoB;AAGtD,KAAI,OAAO,oBACP,wBAAuB,OAAO,oBAAoB;AAGtD,KAAI,OAAO,UACP,sBAAqB,OAAO,UAAU;AAG1C,KAAI,OAAO,WACP,eAAc,OAAO,WAAW"}

package/dist/utils/craftHostBridge.d.ts

@@ -0,0 +1,16 @@
+import { HostElementSelectorOptions, HostRequestConfig, HostRequestMethod, PluginKitReactHostBridge } from './hostBridge';
+type CraftApi = {
+    sendActionRequest: <T = unknown>(method: HostRequestMethod, action: string, requestConfig?: HostRequestConfig) => Promise<T>;
+    createElementSelectorModal: (elementType: string, options: HostElementSelectorOptions) => void;
+    formatDate: (date: Date) => string;
+    timepickerOptions?: Record<string, unknown>;
+    locale?: string;
+};
+declare global {
+    interface Window {
+        Craft?: CraftApi;
+    }
+}
+export declare const createCraftHostBridge: () => Partial<PluginKitReactHostBridge>;
+export {};
+//# sourceMappingURL=craftHostBridge.d.ts.map

package/dist/utils/craftHostBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craftHostBridge.d.ts","sourceRoot":"","sources":["../../src/utils/craftHostBridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EAC3B,MAAM,cAAc,CAAC;AAEtB,KAAK,QAAQ,GAAG;IACZ,iBAAiB,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7H,0BAA0B,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAC/F,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;IACnC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,KAAK,CAAC,EAAE,QAAQ,CAAC;KACpB;CACJ;AAUD,eAAO,MAAM,qBAAqB,QAAO,OAAO,CAAC,wBAAwB,CAkBxE,CAAC"}

package/dist/utils/craftHostBridge.js

@@ -0,0 +1,28 @@
+//#region src/utils/craftHostBridge.ts
+var getCraft = () => {
+	if (!window.Craft) throw new Error("Craft host bridge is unavailable because window.Craft is not defined.");
+	return window.Craft;
+};
+var createCraftHostBridge = () => {
+	return {
+		request: (method, action, requestConfig = {}) => {
+			return getCraft().sendActionRequest(method, action, requestConfig);
+		},
+		openElementSelector: (elementType, options) => {
+			return getCraft().createElementSelectorModal(elementType, options);
+		},
+		formatDate: (date) => {
+			return getCraft().formatDate(date);
+		},
+		getTimepickerOptions: () => {
+			return getCraft().timepickerOptions || {};
+		},
+		getLocale: () => {
+			return getCraft().locale || "en-US";
+		}
+	};
+};
+//#endregion
+export { createCraftHostBridge };
+
+//# sourceMappingURL=craftHostBridge.js.map

package/dist/utils/craftHostBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craftHostBridge.js","names":[],"sources":["../../src/utils/craftHostBridge.ts"],"sourcesContent":["import type {\n    HostElementSelectorOptions,\n    HostRequestConfig,\n    HostRequestMethod,\n    PluginKitReactHostBridge,\n} from './hostBridge';\n\ntype CraftApi = {\n    sendActionRequest: <T = unknown>(method: HostRequestMethod, action: string, requestConfig?: HostRequestConfig) => Promise<T>;\n    createElementSelectorModal: (elementType: string, options: HostElementSelectorOptions) => void;\n    formatDate: (date: Date) => string;\n    timepickerOptions?: Record<string, unknown>;\n    locale?: string;\n};\n\ndeclare global {\n    interface Window {\n        Craft?: CraftApi;\n    }\n}\n\nconst getCraft = (): CraftApi => {\n    if (!window.Craft) {\n        throw new Error('Craft host bridge is unavailable because window.Craft is not defined.');\n    }\n\n    return window.Craft;\n};\n\nexport const createCraftHostBridge = (): Partial<PluginKitReactHostBridge> => {\n    return {\n        request: (method, action, requestConfig = {}) => {\n            return getCraft().sendActionRequest(method, action, requestConfig);\n        },\n        openElementSelector: (elementType, options) => {\n            return getCraft().createElementSelectorModal(elementType, options);\n        },\n        formatDate: (date) => {\n            return getCraft().formatDate(date);\n        },\n        getTimepickerOptions: () => {\n            return getCraft().timepickerOptions || {};\n        },\n        getLocale: () => {\n            return getCraft().locale || 'en-US';\n        },\n    };\n};\n"],"mappings":";AAqBA,IAAM,iBAA2B;AAC7B,KAAI,CAAC,OAAO,MACR,OAAM,IAAI,MAAM,wEAAwE;AAG5F,QAAO,OAAO;;AAGlB,IAAa,8BAAiE;AAC1E,QAAO;EACH,UAAU,QAAQ,QAAQ,gBAAgB,EAAE,KAAK;AAC7C,UAAO,UAAU,CAAC,kBAAkB,QAAQ,QAAQ,cAAc;;EAEtE,sBAAsB,aAAa,YAAY;AAC3C,UAAO,UAAU,CAAC,2BAA2B,aAAa,QAAQ;;EAEtE,aAAa,SAAS;AAClB,UAAO,UAAU,CAAC,WAAW,KAAK;;EAEtC,4BAA4B;AACxB,UAAO,UAAU,CAAC,qBAAqB,EAAE;;EAE7C,iBAAiB;AACb,UAAO,UAAU,CAAC,UAAU;;EAEnC"}

package/dist/utils/handle.d.ts

@@ -0,0 +1,10 @@
+declare const getDynamicReservedHandles: (values: Record<string, unknown>, reservedFieldValues?: string[]) => string[];
+declare const buildUniqueHandleFromSource: ({ sourceValue, values, reservedHandles, reservedFieldValues, maxLength, }: {
+    sourceValue: unknown;
+    values?: Record<string, unknown>;
+    reservedHandles?: string[];
+    reservedFieldValues?: string[];
+    maxLength?: number;
+}) => string;
+export { buildUniqueHandleFromSource, getDynamicReservedHandles };
+//# sourceMappingURL=handle.d.ts.map

package/dist/utils/handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../src/utils/handle.ts"],"names":[],"mappings":"AAeA,QAAA,MAAM,yBAAyB,GAAI,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAqB,MAAM,EAAO,aAgBrG,CAAC;AAkDF,QAAA,MAAM,2BAA2B,GAAI,2EAMlC;IACC,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB,WAMA,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/utils/handle.js

@@ -0,0 +1,51 @@
+import { findUniqueHandle, generateHandle } from "@verbb/plugin-kit";
+import { get } from "lodash-es";
+//#region src/utils/handle.ts
+var normalizeHandleSource = (value) => {
+	if (value == null) return "";
+	return String(value).replace(/\{[^}]*\}/g, " ").replace(/\s+/g, " ").trim();
+};
+var getDynamicReservedHandles = (values, reservedFieldValues = []) => {
+	const dynamicHandles = [];
+	reservedFieldValues.forEach((fieldPath) => {
+		const value = get(values, fieldPath);
+		if (value && typeof value === "string") {
+			const handleValue = generateHandle(normalizeHandleSource(value));
+			if (handleValue) dynamicHandles.push(handleValue);
+		}
+	});
+	return dynamicHandles;
+};
+var truncateHandle = (handle, maxLength) => {
+	if (!Number.isFinite(maxLength)) return handle;
+	const length = Math.max(Number(maxLength), 0);
+	return handle.slice(0, length);
+};
+var findUniqueHandleWithinMaxLength = (baseHandle, reservedHandles = [], maxLength) => {
+	if (!baseHandle) return "";
+	if (!Number.isFinite(maxLength)) return findUniqueHandle(baseHandle, reservedHandles);
+	const normalizedReserved = new Set((reservedHandles || []).map((handle) => {
+		return String(handle || "").toLowerCase();
+	}));
+	const truncatedBase = truncateHandle(baseHandle, maxLength);
+	if (!truncatedBase) return "";
+	if (!normalizedReserved.has(truncatedBase.toLowerCase())) return truncatedBase;
+	let suffix = 1;
+	while (suffix < 1e4) {
+		const suffixText = String(suffix);
+		const baseMaxLength = Math.max(Number(maxLength) - suffixText.length, 0);
+		const truncatedWithSuffix = `${truncatedBase.slice(0, baseMaxLength)}${suffixText}`;
+		if (!normalizedReserved.has(truncatedWithSuffix.toLowerCase())) return truncatedWithSuffix;
+		suffix += 1;
+	}
+	return truncatedBase;
+};
+var buildUniqueHandleFromSource = ({ sourceValue, values = {}, reservedHandles = [], reservedFieldValues = [], maxLength }) => {
+	const baseHandle = generateHandle(normalizeHandleSource(sourceValue));
+	const dynamicHandles = getDynamicReservedHandles(values, reservedFieldValues);
+	return findUniqueHandleWithinMaxLength(baseHandle, [...reservedHandles, ...dynamicHandles], maxLength);
+};
+//#endregion
+export { buildUniqueHandleFromSource, getDynamicReservedHandles };
+
+//# sourceMappingURL=handle.js.map