@progress/sitefinity-webservices-sdk 1.1.16 → 2.0.0

package/esm/chunks/chunk-CMGV26CS.mjs

@@ -0,0 +1,66 @@
+import {
+  utils
+} from "./chunk-2ID24RPE.mjs";
+
+// src/QueryBase.ts
+var QueryBase = class {
+  /** Creates an empty projection. */
+  constructor() {
+    this.selectProperties = null;
+    this.expandProperties = null;
+  }
+  /**
+   * Selects the scalar fields returned by the service.
+   *
+   * Duplicate names are removed while preserving their first occurrence.
+   * Property names must be simple paths without a dot.
+   *
+   * @param properties Field names to include.
+   * @returns A cloned query with `$select` configured.
+   * @throws Error If a property is not a string or is a nested path.
+   */
+  select(...properties) {
+    properties = properties ?? [];
+    this.validatePropertyPaths(properties);
+    return this.clone((newObj) => {
+      newObj.selectProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
+    });
+  }
+  /**
+   * Selects the navigation properties expanded by the service.
+   *
+   * Duplicate names are removed while preserving their first occurrence.
+   * Property names must be simple paths without a dot.
+   *
+   * @param properties Navigation property names to expand.
+   * @returns A cloned query with `$expand` configured.
+   * @throws Error If a property is not a string or is a nested path.
+   */
+  expand(...properties) {
+    properties = properties ?? [];
+    this.validatePropertyPaths(properties);
+    return this.clone((newObj) => {
+      newObj.expandProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
+    });
+  }
+  validatePropertyPaths(propPaths, allowNested = false) {
+    for (let i = 0; i < propPaths.length; i++) {
+      const member = propPaths[i];
+      if (!utils.isString(member)) {
+        throw new Error("Invalid argument in clause");
+      }
+      if (!allowNested && member.indexOf(".") > -1) {
+        throw new Error("Invalid argument in clause");
+      }
+    }
+  }
+  clone(setter = null) {
+    const newObj = utils.clone(this, Object.create(Object.getPrototypeOf(this)), setter);
+    return newObj;
+  }
+};
+
+export {
+  QueryBase
+};
+//# sourceMappingURL=chunk-CMGV26CS.mjs.map

package/esm/chunks/chunk-CMGV26CS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryBase.ts"],
+  "sourcesContent": ["import { utils } from \"./utils\";\n\n/**\n * Base class for query projections.\n *\n * `Query` extends this class with filtering, ordering, searching, and paging.\n * Projection methods are immutable: each call returns a clone that preserves\n * the concrete query prototype, so fluent chains continue to expose derived\n * query methods.\n */\nexport class QueryBase {\n    /** Selected scalar properties, or `null` when no projection was configured. */\n    selectProperties: string[];\n    /** Selected navigation properties, or `null` when no expansion was configured. */\n    expandProperties: string[];\n\n    /** Creates an empty projection. */\n    constructor() {\n        this.selectProperties = null;\n        this.expandProperties = null;\n    }\n\n    /**\n     * Selects the scalar fields returned by the service.\n     *\n     * Duplicate names are removed while preserving their first occurrence.\n     * Property names must be simple paths without a dot.\n     *\n     * @param properties Field names to include.\n     * @returns A cloned query with `$select` configured.\n     * @throws Error If a property is not a string or is a nested path.\n     */\n    select(...properties: string[]): this {\n        properties = properties ?? [];\n\n        this.validatePropertyPaths(properties);\n\n        return this.clone((newObj: this) => {\n            newObj.selectProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);\n        });\n    }\n\n    /**\n     * Selects the navigation properties expanded by the service.\n     *\n     * Duplicate names are removed while preserving their first occurrence.\n     * Property names must be simple paths without a dot.\n     *\n     * @param properties Navigation property names to expand.\n     * @returns A cloned query with `$expand` configured.\n     * @throws Error If a property is not a string or is a nested path.\n     */\n    expand(...properties: string[]): this {\n        properties = properties ?? [];\n        this.validatePropertyPaths(properties);\n\n        return this.clone((newObj: this) => {\n            newObj.expandProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);\n        });\n    }\n\n    protected validatePropertyPaths(propPaths: string[], allowNested = false) {\n        for (let i = 0; i < propPaths.length; i++) {\n            const member = propPaths[i];\n            if (!utils.isString(member)) {\n                throw new Error(\"Invalid argument in clause\");\n            }\n\n            if (!allowNested && member.indexOf(\".\") > -1) {\n                throw new Error(\"Invalid argument in clause\");\n            }\n        }\n    }\n\n    protected clone(setter: ((newObj: this) => void) = null): this {\n        const newObj = utils.clone(this, Object.create(Object.getPrototypeOf(this)), setter) as this;\n        return newObj;\n    }\n}\n"],
+  "mappings": ";;;;;AAUO,IAAM,YAAN,MAAgB;AAAA;AAAA,EAOnB,cAAc;AACV,SAAK,mBAAmB;AACxB,SAAK,mBAAmB;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,UAAU,YAA4B;AAClC,iBAAa,cAAc,CAAC;AAE5B,SAAK,sBAAsB,UAAU;AAErC,WAAO,KAAK,MAAM,CAAC,WAAiB;AAChC,aAAO,mBAAmB,WAAW,OAAO,CAAC,MAAM,OAAO,UAAU,MAAM,QAAQ,IAAI,MAAM,KAAK;AAAA,IACrG,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,UAAU,YAA4B;AAClC,iBAAa,cAAc,CAAC;AAC5B,SAAK,sBAAsB,UAAU;AAErC,WAAO,KAAK,MAAM,CAAC,WAAiB;AAChC,aAAO,mBAAmB,WAAW,OAAO,CAAC,MAAM,OAAO,UAAU,MAAM,QAAQ,IAAI,MAAM,KAAK;AAAA,IACrG,CAAC;AAAA,EACL;AAAA,EAEU,sBAAsB,WAAqB,cAAc,OAAO;AACtE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,YAAM,SAAS,UAAU,CAAC;AAC1B,UAAI,CAAC,MAAM,SAAS,MAAM,GAAG;AACzB,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAChD;AAEA,UAAI,CAAC,eAAe,OAAO,QAAQ,GAAG,IAAI,IAAI;AAC1C,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAChD;AAAA,IACJ;AAAA,EACJ;AAAA,EAEU,MAAM,SAAmC,MAAY;AAC3D,UAAM,SAAS,MAAM,MAAM,MAAM,OAAO,OAAO,OAAO,eAAe,IAAI,CAAC,GAAG,MAAM;AACnF,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/esm/chunks/chunk-DHWDJAGV.mjs

@@ -0,0 +1,180 @@
+import {
+  WhereQuery
+} from "./chunk-BFLQBM7R.mjs";
+import {
+  EXPRESSION_TYPE,
+  ODATA_PARAMS
+} from "./chunk-RQAAYOY6.mjs";
+import {
+  BinaryExpression,
+  ComplexExpression
+} from "./chunk-F4CWOE7M.mjs";
+import {
+  OrderProperty
+} from "./chunk-YB2LMPUX.mjs";
+import {
+  utils
+} from "./chunk-2ID24RPE.mjs";
+
+// src/QueryBuilder.ts
+var QueryBuilder = class {
+  /** Creates a builder for the supplied query. */
+  constructor(query) {
+    this.query = query;
+  }
+  /**
+   * Serializes the query into OData parameter names and values.
+   *
+   * Supported output keys are `$filter`, `$select`, `$expand`, `$orderby`,
+   * `$skip`, `$top`, `$count`, and `$search`. Missing or empty clauses are
+   * omitted. String constants are escaped and quoted; GUID constants remain
+   * unquoted, and `in` requires an array value.
+   *
+   * @returns An object suitable for the data request's query parameters.
+   * @throws Error If the expression tree is invalid, an operator is unsupported,
+   * or an `in` condition does not contain an array.
+   */
+  build() {
+    const queryParameters = {};
+    const whereClause = this.query.filter;
+    if (whereClause instanceof WhereQuery) {
+      const expression = whereClause.getExpression();
+      if (expression instanceof ComplexExpression) {
+        const result = this.buildComplexExpression(expression, null);
+        if (result) {
+          queryParameters[ODATA_PARAMS.$filter] = result;
+        }
+      }
+    }
+    const selectClause = this.query.selectProperties;
+    if (selectClause instanceof Array) {
+      queryParameters[ODATA_PARAMS.$select] = selectClause.join(", ");
+    }
+    const expandClause = this.query.expandProperties;
+    if (expandClause instanceof Array)
+      queryParameters[ODATA_PARAMS.$expand] = expandClause.join(", ");
+    const orderByClause = this.query.orderProperties;
+    if (orderByClause instanceof Array) {
+      const order = [];
+      for (const i in orderByClause) {
+        if (orderByClause[i] instanceof OrderProperty)
+          order.push(orderByClause[i].getValue());
+      }
+      queryParameters[ODATA_PARAMS.$orderby] = order.join(", ");
+    }
+    const take = this.query.takeValue;
+    if (utils.isNumber(take))
+      queryParameters[ODATA_PARAMS.$top] = take;
+    const skip = this.query.skipValue;
+    if (utils.isNumber(skip))
+      queryParameters[ODATA_PARAMS.$skip] = skip;
+    const search = this.query.searchValue;
+    if (search)
+      queryParameters[ODATA_PARAMS.$search] = search;
+    if (this.query.inlineCount !== null) {
+      queryParameters[ODATA_PARAMS.$count] = this.query.inlineCount;
+    }
+    return queryParameters;
+  }
+  buildComplexExpression(expression, parent) {
+    if (!(expression instanceof ComplexExpression))
+      throw new Error("Invalid complex expression");
+    let counter = 0;
+    let result = "";
+    const subExpressions = expression.getExpressions();
+    if (!subExpressions.length) {
+      return result;
+    }
+    while (true) {
+      const currentExp = subExpressions[counter];
+      if (currentExp instanceof BinaryExpression) {
+        result += this.buildBinaryExpression(currentExp);
+      } else if (currentExp instanceof ComplexExpression) {
+        const complexResult = this.buildComplexExpression(currentExp, expression.type);
+        if (complexResult) {
+          result += "(" + complexResult + ")";
+        }
+      }
+      if (expression.getType() === EXPRESSION_TYPE.not)
+        result = expression.getType() + " " + result;
+      if (expression.getType() === EXPRESSION_TYPE.any) {
+        const exprVal = [];
+        for (let index = 0; index < subExpressions.length; index++) {
+          if (subExpressions[index].type == EXPRESSION_TYPE.contains || subExpressions[index].type == EXPRESSION_TYPE.startsWith || subExpressions[index].type == EXPRESSION_TYPE.endsWith)
+            exprVal.push(subExpressions[index].type.toLowerCase() + "(x, '" + subExpressions[index].constant + "')");
+          else
+            exprVal.push("x " + subExpressions[index].type.toLowerCase() + " " + this.checkType(subExpressions[index].constant));
+        }
+        result = currentExp.parameter + "/" + expression.getType() + "(x:" + exprVal.join(" " + parent + " ") + ")";
+      }
+      counter++;
+      if (counter == subExpressions.length)
+        break;
+      result += " " + expression.getType() + " ";
+    }
+    return result;
+  }
+  buildBinaryExpression(expression) {
+    let result = null;
+    const type = expression.getType();
+    switch (type) {
+      case EXPRESSION_TYPE.eq:
+      case EXPRESSION_TYPE.ne:
+      case EXPRESSION_TYPE.lt:
+      case EXPRESSION_TYPE.le:
+      case EXPRESSION_TYPE.gt:
+      case EXPRESSION_TYPE.ge: {
+        const constant = expression.getConstant();
+        result = `(${expression.getParameter()} ${type} ${this.checkType(constant)})`;
+        break;
+      }
+      case EXPRESSION_TYPE.contains:
+      case EXPRESSION_TYPE.startsWith:
+      case EXPRESSION_TYPE.endsWith: {
+        const expressionParameter = this.applyCaseSensitiveSettings(expression, expression.getParameter());
+        const expressionConstant = this.checkType(expression.getConstant(), true);
+        const expressionValue = this.applyCaseSensitiveSettings(expression, expressionConstant);
+        result = `${type.toLowerCase()}(${expressionParameter}, ${expressionValue})`;
+        break;
+      }
+      case EXPRESSION_TYPE.in: {
+        const valueArray = expression.getConstant();
+        if (!Array.isArray(valueArray)) {
+          throw new Error("Parameter is not an array!");
+        }
+        result = `${expression.getParameter()} in (${valueArray.join(", ")})`;
+        break;
+      }
+      default: {
+        const msg = `Unsupported operator ${type}`;
+        throw new Error(msg);
+      }
+    }
+    return result;
+  }
+  applyCaseSensitiveSettings(expression, value) {
+    if (expression.isCaseSensitive()) {
+      return value;
+    }
+    return `tolower(${value})`;
+  }
+  checkType(constant, treatAsString = false) {
+    if (this.isGuid(constant) && !treatAsString)
+      return constant;
+    if (constant == null)
+      return null;
+    constant = constant.replace(/[+/?%#&]/g, function($0) {
+      return encodeURIComponent($0);
+    });
+    constant = constant.replace(/'/g, "''");
+    return "'" + constant + "'";
+  }
+  isGuid(constant) {
+    return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(constant);
+  }
+};
+
+export {
+  QueryBuilder
+};
+//# sourceMappingURL=chunk-DHWDJAGV.mjs.map

package/esm/chunks/chunk-DHWDJAGV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryBuilder.ts"],
+  "sourcesContent": ["\uFEFFimport { WhereQuery } from \"./WhereQuery\";\nimport { ComplexExpression, BinaryExpression } from \"./Expression\";\nimport { OrderProperty } from \"./OrderProperty\";\nimport { utils } from \"./utils\";\nimport { ODATA_PARAMS, EXPRESSION_TYPE } from \"./constants\";\nimport { Query } from \"./Query\";\n\n/**\n * Serializes a {@link Query} and its expression tree to OData query parameters.\n */\nexport class QueryBuilder {\n    /** Creates a builder for the supplied query. */\n    constructor(private query: Query) {\n    }\n\n    /**\n     * Serializes the query into OData parameter names and values.\n     *\n     * Supported output keys are `$filter`, `$select`, `$expand`, `$orderby`,\n     * `$skip`, `$top`, `$count`, and `$search`. Missing or empty clauses are\n     * omitted. String constants are escaped and quoted; GUID constants remain\n     * unquoted, and `in` requires an array value.\n     *\n     * @returns An object suitable for the data request's query parameters.\n     * @throws Error If the expression tree is invalid, an operator is unsupported,\n     * or an `in` condition does not contain an array.\n     */\n    build(): { [key: string]: string } {\n        const queryParameters = {};\n        const whereClause = this.query.filter;\n        if (whereClause instanceof WhereQuery) {\n            const expression = whereClause.getExpression();\n            if (expression instanceof ComplexExpression) {\n                const result = this.buildComplexExpression(expression, null);\n                if (result) {\n                    queryParameters[ODATA_PARAMS.$filter] = result;\n                }\n            }\n        }\n\n        const selectClause = this.query.selectProperties;\n        if (selectClause instanceof Array) {\n            queryParameters[ODATA_PARAMS.$select] = selectClause.join(\", \");\n        }\n\n        const expandClause = this.query.expandProperties;\n        if (expandClause instanceof Array)\n            queryParameters[ODATA_PARAMS.$expand] = expandClause.join(\", \");\n\n        const orderByClause = this.query.orderProperties;\n        if (orderByClause instanceof Array) {\n            const order = [];\n            for (const i in orderByClause) {\n                if (orderByClause[i] instanceof OrderProperty)\n                    order.push(orderByClause[i].getValue());\n            }\n            queryParameters[ODATA_PARAMS.$orderby] = order.join(\", \");\n        }\n\n        const take = this.query.takeValue;\n        if (utils.isNumber(take))\n            queryParameters[ODATA_PARAMS.$top] = take;\n\n        const skip = this.query.skipValue;\n        if (utils.isNumber(skip))\n            queryParameters[ODATA_PARAMS.$skip] = skip;\n\n        const search = this.query.searchValue;\n        if (search)\n            queryParameters[ODATA_PARAMS.$search] = search;\n\n        if (this.query.inlineCount !== null) {\n            queryParameters[ODATA_PARAMS.$count] = this.query.inlineCount;\n        }\n\n        return queryParameters;\n    }\n\n    private buildComplexExpression(expression: ComplexExpression, parent: string): string {\n        if (!(expression instanceof ComplexExpression))\n            throw new Error(\"Invalid complex expression\");\n\n        let counter = 0;\n        let result = \"\";\n        const subExpressions = expression.getExpressions();\n        if (!subExpressions.length) {\n            return result;\n        }\n\n        while (true) {\n            const currentExp = subExpressions[counter];\n            if (currentExp instanceof BinaryExpression) {\n                result += this.buildBinaryExpression(currentExp);\n            }\n            else if (currentExp instanceof ComplexExpression) {\n                const complexResult = this.buildComplexExpression(currentExp, expression.type);\n                if (complexResult) {\n                    result += \"(\" + complexResult + \")\";\n                }\n            }\n\n            if (expression.getType() === EXPRESSION_TYPE.not)\n                result = expression.getType() + \" \" + result;\n            // TODOSDK: Rethink this!\n            if (expression.getType() === EXPRESSION_TYPE.any) {\n                const exprVal = [];\n                for (let index = 0; index < subExpressions.length; index++) {\n                    if (subExpressions[index].type == EXPRESSION_TYPE.contains || subExpressions[index].type == EXPRESSION_TYPE.startsWith || subExpressions[index].type == EXPRESSION_TYPE.endsWith)\n                        exprVal.push(subExpressions[index].type.toLowerCase() + \"(x, '\" + (subExpressions[index] as BinaryExpression).constant + \"')\");\n                    else\n                        exprVal.push(\"x \" + subExpressions[index].type.toLowerCase() + \" \" + this.checkType((subExpressions[index] as BinaryExpression).constant));\n                }\n                result = (currentExp as BinaryExpression).parameter + \"/\" + expression.getType() + \"(x:\" + exprVal.join(\" \" + parent + \" \") + \")\";\n            }\n\n            counter++;\n            if (counter == subExpressions.length)\n                break;\n\n            result += \" \" + expression.getType() + \" \";\n        }\n\n        return result;\n    }\n\n    private buildBinaryExpression(expression: BinaryExpression): string {\n        let result: string = null;\n        const type = expression.getType();\n        switch (type) {\n        case EXPRESSION_TYPE.eq:\n        case EXPRESSION_TYPE.ne:\n        case EXPRESSION_TYPE.lt:\n        case EXPRESSION_TYPE.le:\n        case EXPRESSION_TYPE.gt:\n        case EXPRESSION_TYPE.ge: {\n            const constant = expression.getConstant();\n            result = `(${expression.getParameter()} ${type} ${this.checkType(constant)})`;\n            break;\n        }\n        case EXPRESSION_TYPE.contains:\n        case EXPRESSION_TYPE.startsWith:\n        case EXPRESSION_TYPE.endsWith: {\n            const expressionParameter = this.applyCaseSensitiveSettings(expression, expression.getParameter());\n            const expressionConstant =  this.checkType(expression.getConstant(), true);\n            const expressionValue = this.applyCaseSensitiveSettings(expression, expressionConstant);\n\n            result = `${type.toLowerCase()}(${expressionParameter}, ${expressionValue})`;\n            break;\n        }\n        case EXPRESSION_TYPE.in: {\n            const valueArray = expression.getConstant();\n            if (!Array.isArray(valueArray)) {\n                throw new Error(\"Parameter is not an array!\");\n            }\n\n            result = `${expression.getParameter()} in (${valueArray.join(\", \")})`;\n            break;\n        }\n        default: {\n            const msg = `Unsupported operator ${type}`;\n            throw new Error(msg);\n        }\n        }\n\n        return result;\n    }\n\n    private applyCaseSensitiveSettings(expression: BinaryExpression, value: string): string {\n        if (expression.isCaseSensitive()) {\n            return value;\n        }\n\n        return `tolower(${value})`;\n    }\n\n    private checkType(constant: any, treatAsString = false): string {\n        if (this.isGuid(constant) && !treatAsString)\n            return constant;\n\n        if (constant == null)\n            return null;\n\n        constant = constant.replace(/[+/?%#&]/g, function ($0) {\n            return encodeURIComponent($0);\n        });\n\n        // escapes the apostrophes\n        constant = constant.replace(/'/g, \"''\");\n\n        return \"'\" + constant + \"'\";\n    }\n\n    private isGuid(constant: string): boolean {\n        return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(constant);\n    }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/esm/chunks/chunk-EH4CERVO.mjs

@@ -0,0 +1,82 @@
+// src/chunk-upload/chunked-file-upload.utilities.ts
+var ChunkedFileUploadUtilities = class {
+  /**
+   * Splits a `Blob` or base64-encoded binary string into sequential chunks.
+   *
+   * Blob input is sliced directly. A base64 string is decoded with `atob`
+   * into a Blob using `contentTypeMime` before it is sliced. Chunk ordinals
+   * start at zero; the final chunk can be smaller than `chunkSize`.
+   *
+   * @param file Blob data or a base64-encoded binary string.
+   * @param chunkSize Maximum size of each chunk in bytes.
+   * @param contentTypeMime MIME type assigned to each chunk and decoded Blob.
+   * @returns The chunks, their total count, and the original file size in bytes.
+   *
+   * @example
+   * ```ts
+   * const result = new ChunkedFileUploadUtilities().chunkFile(
+   *     base64File,
+   *     5 * 1024 * 1024,
+   *     "image/jpeg"
+   * );
+   *
+   * result.chunks.forEach(({ ordinal, content }) => {
+   *     console.log(`Chunk ${ordinal}: ${content.size} bytes`);
+   * });
+   * ```
+   */
+  chunkFile(file, chunkSize, contentTypeMime) {
+    let fileInternal;
+    if (typeof file === "string")
+      fileInternal = this.base64ToBlob(file, chunkSize, contentTypeMime);
+    else {
+      fileInternal = file;
+    }
+    const fileSize = fileInternal.size;
+    const result = [];
+    let chunkOrdinal = 0;
+    let offset = 0;
+    let currentOffset = chunkSize;
+    while (offset <= fileSize) {
+      const chunk = fileInternal.slice(offset, currentOffset, contentTypeMime);
+      offset = currentOffset;
+      currentOffset = currentOffset + chunkSize;
+      result.push({
+        ordinal: chunkOrdinal,
+        content: chunk
+      });
+      chunkOrdinal++;
+    }
+    return {
+      chunks: result,
+      totalChunksCount: result.length,
+      fileTotalSize: fileSize
+    };
+  }
+  /**
+   * Converts base64 binary content to a Blob before chunking.
+   *
+   * The input must contain the base64 payload expected by `atob`; a data URL
+   * prefix is not removed automatically.
+   */
+  base64ToBlob(base64String, chunkSize, contentType = "") {
+    const byteCharacters = atob(base64String);
+    const byteArrays = [];
+    for (let offset = 0; offset < byteCharacters.length; offset += chunkSize) {
+      const slice = byteCharacters.slice(offset, offset + chunkSize);
+      const byteNumbers = new Array(slice.length);
+      for (let i = 0; i < slice.length; i++) {
+        byteNumbers[i] = slice.charCodeAt(i);
+      }
+      const byteArray = new Uint8Array(byteNumbers);
+      byteArrays.push(byteArray);
+    }
+    const blob = new Blob(byteArrays, { type: contentType });
+    return blob;
+  }
+};
+
+export {
+  ChunkedFileUploadUtilities
+};
+//# sourceMappingURL=chunk-EH4CERVO.mjs.map

package/esm/chunks/chunk-EH4CERVO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/chunk-upload/chunked-file-upload.utilities.ts"],
+  "sourcesContent": ["/**\n * Helpers for splitting file content into chunks and normalizing upload input.\n */\nexport class ChunkedFileUploadUtilities {\n    /**\n     * Splits a `Blob` or base64-encoded binary string into sequential chunks.\n     *\n     * Blob input is sliced directly. A base64 string is decoded with `atob`\n     * into a Blob using `contentTypeMime` before it is sliced. Chunk ordinals\n     * start at zero; the final chunk can be smaller than `chunkSize`.\n     *\n     * @param file Blob data or a base64-encoded binary string.\n     * @param chunkSize Maximum size of each chunk in bytes.\n     * @param contentTypeMime MIME type assigned to each chunk and decoded Blob.\n     * @returns The chunks, their total count, and the original file size in bytes.\n     *\n     * @example\n     * ```ts\n     * const result = new ChunkedFileUploadUtilities().chunkFile(\n     *     base64File,\n     *     5 * 1024 * 1024,\n     *     \"image/jpeg\"\n     * );\n     *\n     * result.chunks.forEach(({ ordinal, content }) => {\n     *     console.log(`Chunk ${ordinal}: ${content.size} bytes`);\n     * });\n     * ```\n     */\n    chunkFile(file: Blob | string, chunkSize: number, contentTypeMime: string): ChunkFileResult {\n        let fileInternal: Blob;\n\n        if (typeof file === \"string\")\n            fileInternal = this.base64ToBlob(file, chunkSize, contentTypeMime);\n        else {\n            fileInternal = file as Blob;\n        }\n\n        const fileSize = fileInternal.size;\n        const result: Array<FileUploadChunk> = [];\n        let chunkOrdinal = 0;\n        let offset = 0;\n        let currentOffset = chunkSize;\n\n        while (offset <= fileSize) {\n            const chunk = fileInternal.slice(offset, currentOffset, contentTypeMime);\n            offset = currentOffset;\n            currentOffset = currentOffset + chunkSize;\n\n            result.push({\n                ordinal: chunkOrdinal,\n                content: chunk\n            });\n\n            chunkOrdinal++;\n        }\n\n        return {\n            chunks: result,\n            totalChunksCount: result.length,\n            fileTotalSize: fileSize\n        };\n    }\n\n    /**\n     * Converts base64 binary content to a Blob before chunking.\n     *\n     * The input must contain the base64 payload expected by `atob`; a data URL\n     * prefix is not removed automatically.\n     */\n    private base64ToBlob(base64String, chunkSize, contentType = \"\"): Blob {\n        const byteCharacters = atob(base64String);\n        const byteArrays = [];\n        for (let offset = 0; offset < byteCharacters.length; offset += chunkSize) {\n            const slice = byteCharacters.slice(offset, offset + chunkSize);\n            const byteNumbers = new Array(slice.length);\n            for (let i = 0; i < slice.length; i++) {\n                byteNumbers[i] = slice.charCodeAt(i);\n            }\n            const byteArray = new Uint8Array(byteNumbers);\n            byteArrays.push(byteArray);\n        }\n\n        const blob = new Blob(byteArrays, { type: contentType });\n        return blob;\n    }\n}\n\n/**\n * One chunk produced by {@link ChunkedFileUploadUtilities.chunkFile}.\n */\nexport interface FileUploadChunk {\n    /** Zero-based position of this chunk in the complete file. */\n    ordinal: number,\n    /** Binary content for this chunk. */\n    content: Blob\n}\n\n/**\n * Result returned after a file is divided into upload chunks.\n */\nexport interface ChunkFileResult {\n    /** Chunks in ascending ordinal order. */\n    chunks: Array<FileUploadChunk>,\n    /** Number of chunks in `chunks`. */\n    totalChunksCount: number,\n    /** Size of the source file in bytes. */\n    fileTotalSize: number\n}\n"],
+  "mappings": ";AAGO,IAAM,6BAAN,MAAiC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BpC,UAAU,MAAqB,WAAmB,iBAA0C;AACxF,QAAI;AAEJ,QAAI,OAAO,SAAS;AAChB,qBAAe,KAAK,aAAa,MAAM,WAAW,eAAe;AAAA,SAChE;AACD,qBAAe;AAAA,IACnB;AAEA,UAAM,WAAW,aAAa;AAC9B,UAAM,SAAiC,CAAC;AACxC,QAAI,eAAe;AACnB,QAAI,SAAS;AACb,QAAI,gBAAgB;AAEpB,WAAO,UAAU,UAAU;AACvB,YAAM,QAAQ,aAAa,MAAM,QAAQ,eAAe,eAAe;AACvE,eAAS;AACT,sBAAgB,gBAAgB;AAEhC,aAAO,KAAK;AAAA,QACR,SAAS;AAAA,QACT,SAAS;AAAA,MACb,CAAC;AAED;AAAA,IACJ;AAEA,WAAO;AAAA,MACH,QAAQ;AAAA,MACR,kBAAkB,OAAO;AAAA,MACzB,eAAe;AAAA,IACnB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,aAAa,cAAc,WAAW,cAAc,IAAU;AAClE,UAAM,iBAAiB,KAAK,YAAY;AACxC,UAAM,aAAa,CAAC;AACpB,aAAS,SAAS,GAAG,SAAS,eAAe,QAAQ,UAAU,WAAW;AACtE,YAAM,QAAQ,eAAe,MAAM,QAAQ,SAAS,SAAS;AAC7D,YAAM,cAAc,IAAI,MAAM,MAAM,MAAM;AAC1C,eAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,oBAAY,CAAC,IAAI,MAAM,WAAW,CAAC;AAAA,MACvC;AACA,YAAM,YAAY,IAAI,WAAW,WAAW;AAC5C,iBAAW,KAAK,SAAS;AAAA,IAC7B;AAEA,UAAM,OAAO,IAAI,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACvD,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/esm/chunks/chunk-F4CWOE7M.mjs

@@ -0,0 +1,57 @@
+// src/Expression.ts
+var ExpressionBase = class {
+  /** Creates an expression node with the specified operator or logical type. */
+  constructor(type) {
+    this.type = type;
+  }
+  /** Returns this expression's operator or logical type. */
+  getType() {
+    return this.type;
+  }
+};
+var BinaryExpression = class extends ExpressionBase {
+  /**
+   * Creates a comparison expression.
+   *
+   * @param type Supported comparison operator, such as `eq`, `ne`, or `contains`.
+   * @param parameter Property being tested.
+   * @param constant Value compared with the property.
+   * @param caseSensitive Whether string functions should preserve case.
+   */
+  constructor(type, parameter, constant, caseSensitive = true) {
+    super(type);
+    this.parameter = parameter;
+    this.constant = constant;
+    this.caseSensitive = caseSensitive;
+  }
+  /** Returns the property being compared. */
+  getParameter() {
+    return this.parameter;
+  }
+  /** Returns the comparison value. */
+  getConstant() {
+    return this.constant;
+  }
+  /** Returns whether string matching preserves case. */
+  isCaseSensitive() {
+    return this.caseSensitive;
+  }
+};
+var ComplexExpression = class extends ExpressionBase {
+  /** Creates a logical expression containing the supplied child nodes. */
+  constructor(type, expressions) {
+    super(type);
+    this.expressions = expressions;
+  }
+  /** Returns the child expressions in their current order. */
+  getExpressions() {
+    return this.expressions;
+  }
+};
+
+export {
+  ExpressionBase,
+  BinaryExpression,
+  ComplexExpression
+};
+//# sourceMappingURL=chunk-F4CWOE7M.mjs.map

package/esm/chunks/chunk-F4CWOE7M.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Expression.ts"],
+  "sourcesContent": ["/** Base node for a query filter expression. */\nexport class ExpressionBase {\n    /** Creates an expression node with the specified operator or logical type. */\n    constructor(public type: string) {\n    }\n\n    /** Returns this expression's operator or logical type. */\n    getType(): string {\n        return this.type;\n    }\n}\n\n/** A filter expression comparing one property with one constant value. */\nexport class BinaryExpression extends ExpressionBase {\n    /**\n     * Creates a comparison expression.\n     *\n     * @param type Supported comparison operator, such as `eq`, `ne`, or `contains`.\n     * @param parameter Property being tested.\n     * @param constant Value compared with the property.\n     * @param caseSensitive Whether string functions should preserve case.\n     */\n    constructor(type: string, public parameter: string, public constant: any, public caseSensitive: boolean = true) {\n        super(type);\n    }\n\n    /** Returns the property being compared. */\n    getParameter(): string {\n        return this.parameter;\n    }\n\n    /** Returns the comparison value. */\n    getConstant(): any {\n        return this.constant;\n    }\n\n    /** Returns whether string matching preserves case. */\n    isCaseSensitive(): boolean {\n        return this.caseSensitive;\n    }\n}\n\n/** A filter expression containing one or more child expression nodes. */\nexport class ComplexExpression extends ExpressionBase {\n    /** Creates a logical expression containing the supplied child nodes. */\n    constructor(type: string, private expressions: ExpressionBase[]) {\n        super(type);\n    }\n\n    /** Returns the child expressions in their current order. */\n    getExpressions(): ExpressionBase[] {\n        return this.expressions;\n    }\n}\n"],
+  "mappings": ";AACO,IAAM,iBAAN,MAAqB;AAAA;AAAA,EAExB,YAAmB,MAAc;AAAd;AAAA,EACnB;AAAA;AAAA,EAGA,UAAkB;AACd,WAAO,KAAK;AAAA,EAChB;AACJ;AAGO,IAAM,mBAAN,cAA+B,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASjD,YAAY,MAAqB,WAA0B,UAAsB,gBAAyB,MAAM;AAC5G,UAAM,IAAI;AADmB;AAA0B;AAAsB;AAAA,EAEjF;AAAA;AAAA,EAGA,eAAuB;AACnB,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGA,cAAmB;AACf,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGA,kBAA2B;AACvB,WAAO,KAAK;AAAA,EAChB;AACJ;AAGO,IAAM,oBAAN,cAAgC,eAAe;AAAA;AAAA,EAElD,YAAY,MAAsB,aAA+B;AAC7D,UAAM,IAAI;AADoB;AAAA,EAElC;AAAA;AAAA,EAGA,iBAAmC;AAC/B,WAAO,KAAK;AAAA,EAChB;AACJ;",
+  "names": []
+}

package/esm/chunks/chunk-FUFBYOIF.mjs

@@ -0,0 +1,98 @@
+import {
+  XhrTransport
+} from "./chunk-WX5J7F5D.mjs";
+import {
+  RequestBase
+} from "./chunk-TTVNTTW5.mjs";
+import {
+  HEADER_NAMES
+} from "./chunk-RQAAYOY6.mjs";
+import {
+  utils
+} from "./chunk-2ID24RPE.mjs";
+
+// src/Requests/ExecutableRequest.ts
+var defaultTransport = new XhrTransport();
+var ExecutableRequest = class extends RequestBase {
+  /**
+   * Creates an executable request with authentication and SDK-wide execution options.
+   *
+   * @param requestOptions Request URL, query, data, and callback options.
+   * @param token Optional bearer token or legacy authorization header value.
+   * @param sdkOptions SDK-wide handlers and request behavior options.
+   */
+  constructor(requestOptions, token, sdkOptions) {
+    super(requestOptions);
+    this.token = token;
+    this.successCb = this.successCb || sdkOptions.handlers?.successCb;
+    this.failureCb = this.failureCb || sdkOptions.handlers?.failureCb;
+    this.enableUnlimitedChoices = sdkOptions.enableUnlimitedChoices;
+    this.integrationMode = sdkOptions.integrationMode;
+    this.transport = sdkOptions.transport ?? defaultTransport;
+  }
+  /**
+   * Sends the request asynchronously.
+   *
+   * Successful responses are passed to `successCb`; HTTP errors are normalized and passed to
+   * `failureCb`. The method returns immediately and does not return a promise or response value.
+   */
+  execute() {
+    this.transport.send(
+      {
+        method: this.getMethod(),
+        url: this.buildUrl(),
+        headers: this.buildHeaders(),
+        body: utils.serializeToJSON(this.getBody()),
+        onUploadProgress: utils.isFunction(this.progressCb) ? (event) => this.progressCb(this.getProgressPayload(event)) : void 0
+      },
+      (response) => this.handleResponse(response)
+    );
+  }
+  /** Maps the transport's upload progress event to the value passed to `progressCb`. */
+  getProgressPayload(event) {
+    return event;
+  }
+  handleResponse(response) {
+    if (response.status > 0) {
+      let data = this.parseResponse(response);
+      if (response.status >= 200 && response.status <= 206) {
+        if (this.successCb && utils.isFunction(this.successCb)) {
+          this.successCb(data);
+        }
+      } else if (response.status >= 400) {
+        if (utils.isString(data)) {
+          data = {
+            message: data
+          };
+        }
+        data.status = response.status;
+        if (this.failureCb && utils.isFunction(this.failureCb)) {
+          this.failureCb(data);
+        }
+      }
+    }
+  }
+  buildHeaders() {
+    const headers = { ...this.getHeaders() };
+    if (this.token) {
+      if (typeof this.token === "string") {
+        headers[HEADER_NAMES.authorization] = this.token;
+      } else {
+        headers[HEADER_NAMES.authorization] = this.token.type + " " + this.token.value;
+      }
+    }
+    if (this.enableUnlimitedChoices) {
+      headers[HEADER_NAMES.choicesBinaryRepresentation] = "true";
+    }
+    if (this.integrationMode) {
+      headers[HEADER_NAMES.integrationMode] = "true";
+    }
+    headers[HEADER_NAMES.serviceRequest] = "true";
+    return headers;
+  }
+};
+
+export {
+  ExecutableRequest
+};
+//# sourceMappingURL=chunk-FUFBYOIF.mjs.map

package/esm/chunks/chunk-FUFBYOIF.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Requests/ExecutableRequest.ts"],
+  "sourcesContent": ["import { RequestBase, RequestOptionsBaseExtended } from \"./RequestBase\";\nimport { utils } from \"../utils\";\nimport { HEADER_NAMES } from \"../constants\";\nimport { AuthorizationToken, SDKOptions } from \"../Sitefinity\";\nimport { HttpTransport, HttpTransportProgressEvent, HttpTransportResponse } from \"../Transport/HttpTransport\";\nimport { XhrTransport } from \"../Transport/XhrTransport\";\n\nconst defaultTransport = new XhrTransport();\n\n/**\n * Request base class that executes an asynchronous HTTP request through the configured transport.\n *\n * This is an advanced API. Execution uses callbacks rather than promises and invokes the configured\n * success, failure, and progress handlers when appropriate.\n */\nexport class ExecutableRequest extends RequestBase {\n    private token: AuthorizationToken;\n    private enableUnlimitedChoices: boolean;\n    private integrationMode: boolean;\n    private transport: HttpTransport;\n\n    /**\n     * Creates an executable request with authentication and SDK-wide execution options.\n     *\n     * @param requestOptions Request URL, query, data, and callback options.\n     * @param token Optional bearer token or legacy authorization header value.\n     * @param sdkOptions SDK-wide handlers and request behavior options.\n     */\n    constructor(requestOptions: RequestOptionsBaseExtended, token: AuthorizationToken, sdkOptions: SDKOptions) {\n        super(requestOptions);\n        this.token = token;\n        this.successCb = this.successCb || sdkOptions.handlers?.successCb;\n        this.failureCb = this.failureCb || sdkOptions.handlers?.failureCb;\n        this.enableUnlimitedChoices = sdkOptions.enableUnlimitedChoices;\n        this.integrationMode = sdkOptions.integrationMode;\n        this.transport = sdkOptions.transport ?? defaultTransport;\n    }\n\n    /**\n     * Sends the request asynchronously.\n     *\n     * Successful responses are passed to `successCb`; HTTP errors are normalized and passed to\n     * `failureCb`. The method returns immediately and does not return a promise or response value.\n     */\n    execute() {\n        this.transport.send(\n            {\n                method: this.getMethod(),\n                url: this.buildUrl(),\n                headers: this.buildHeaders(),\n                body: utils.serializeToJSON(this.getBody()),\n                onUploadProgress: utils.isFunction(this.progressCb)\n                    ? (event) => this.progressCb(this.getProgressPayload(event))\n                    : undefined\n            },\n            (response) => this.handleResponse(response)\n        );\n    }\n\n    /** Maps the transport's upload progress event to the value passed to `progressCb`. */\n    protected getProgressPayload(event: HttpTransportProgressEvent): object {\n        return event;\n    }\n\n    private handleResponse(response: HttpTransportResponse) {\n        if (response.status > 0) {\n            let data = this.parseResponse(response);\n\n            if (response.status >= 200 && response.status <= 206) {\n                if (this.successCb && utils.isFunction(this.successCb)) {\n                    this.successCb(data);\n                }\n            }\n            else if (response.status >= 400) {\n                // When the data is string, we save the string as message\n                // and convert the data to normal object with message property\n                if (utils.isString(data)) {\n                    data = {\n                        message: data\n                    };\n                }\n\n                data.status = response.status;\n\n                // in case of errors we would like there to be one handler for all of the errors\n                if (this.failureCb && utils.isFunction(this.failureCb)) {\n                    this.failureCb(data);\n                }\n            }\n        }\n    }\n\n    private buildHeaders(): { [key: string]: string } {\n        // Copied because getHeaders() can return the caller's shared additionalHeaders object.\n        const headers = { ...this.getHeaders() };\n\n        if (this.token) {\n            if (typeof this.token === \"string\") {\n                // for backward compatibility\n                headers[HEADER_NAMES.authorization] = this.token;\n            } else {\n                headers[HEADER_NAMES.authorization] = this.token.type + \" \" + this.token.value;\n            }\n        }\n\n        if (this.enableUnlimitedChoices) {\n            headers[HEADER_NAMES.choicesBinaryRepresentation] = \"true\";\n        }\n\n        if (this.integrationMode) {\n            headers[HEADER_NAMES.integrationMode] = \"true\";\n        }\n\n        // for backward compatibility\n        headers[HEADER_NAMES.serviceRequest] = \"true\";\n\n        return headers;\n    }\n}\n\n/**\n * Default success and failure callbacks for SDK requests.\n */\nexport interface ResponseHandlers {\n    /** Callback invoked with the parsed successful response. */\n    successCb?: Function;\n    /** Callback invoked with the parsed error response and HTTP status. */\n    failureCb?: Function;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAOA,IAAM,mBAAmB,IAAI,aAAa;AAQnC,IAAM,oBAAN,cAAgC,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa/C,YAAY,gBAA4C,OAA2B,YAAwB;AACvG,UAAM,cAAc;AACpB,SAAK,QAAQ;AACb,SAAK,YAAY,KAAK,aAAa,WAAW,UAAU;AACxD,SAAK,YAAY,KAAK,aAAa,WAAW,UAAU;AACxD,SAAK,yBAAyB,WAAW;AACzC,SAAK,kBAAkB,WAAW;AAClC,SAAK,YAAY,WAAW,aAAa;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAU;AACN,SAAK,UAAU;AAAA,MACX;AAAA,QACI,QAAQ,KAAK,UAAU;AAAA,QACvB,KAAK,KAAK,SAAS;AAAA,QACnB,SAAS,KAAK,aAAa;AAAA,QAC3B,MAAM,MAAM,gBAAgB,KAAK,QAAQ,CAAC;AAAA,QAC1C,kBAAkB,MAAM,WAAW,KAAK,UAAU,IAC5C,CAAC,UAAU,KAAK,WAAW,KAAK,mBAAmB,KAAK,CAAC,IACzD;AAAA,MACV;AAAA,MACA,CAAC,aAAa,KAAK,eAAe,QAAQ;AAAA,IAC9C;AAAA,EACJ;AAAA;AAAA,EAGU,mBAAmB,OAA2C;AACpE,WAAO;AAAA,EACX;AAAA,EAEQ,eAAe,UAAiC;AACpD,QAAI,SAAS,SAAS,GAAG;AACrB,UAAI,OAAO,KAAK,cAAc,QAAQ;AAEtC,UAAI,SAAS,UAAU,OAAO,SAAS,UAAU,KAAK;AAClD,YAAI,KAAK,aAAa,MAAM,WAAW,KAAK,SAAS,GAAG;AACpD,eAAK,UAAU,IAAI;AAAA,QACvB;AAAA,MACJ,WACS,SAAS,UAAU,KAAK;AAG7B,YAAI,MAAM,SAAS,IAAI,GAAG;AACtB,iBAAO;AAAA,YACH,SAAS;AAAA,UACb;AAAA,QACJ;AAEA,aAAK,SAAS,SAAS;AAGvB,YAAI,KAAK,aAAa,MAAM,WAAW,KAAK,SAAS,GAAG;AACpD,eAAK,UAAU,IAAI;AAAA,QACvB;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAAA,EAEQ,eAA0C;AAE9C,UAAM,UAAU,EAAE,GAAG,KAAK,WAAW,EAAE;AAEvC,QAAI,KAAK,OAAO;AACZ,UAAI,OAAO,KAAK,UAAU,UAAU;AAEhC,gBAAQ,aAAa,aAAa,IAAI,KAAK;AAAA,MAC/C,OAAO;AACH,gBAAQ,aAAa,aAAa,IAAI,KAAK,MAAM,OAAO,MAAM,KAAK,MAAM;AAAA,MAC7E;AAAA,IACJ;AAEA,QAAI,KAAK,wBAAwB;AAC7B,cAAQ,aAAa,2BAA2B,IAAI;AAAA,IACxD;AAEA,QAAI,KAAK,iBAAiB;AACtB,cAAQ,aAAa,eAAe,IAAI;AAAA,IAC5C;AAGA,YAAQ,aAAa,cAAc,IAAI;AAEvC,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}