@marteye/studiojs 1.1.24 → 1.1.25

package/dist/index.esm.js

@@ -4554,7 +4554,12 @@ z.object({
     suffix: z.string().min(1, { message: "Suffix Type is required" }),
 });
 // Adding Sizes here will make more end points in the mainConfig object
-const IMAGE_SIZES_VALUES$1 = ["small", "medium", "large"];
+const IMAGE_SIZES_VALUES$1 = [
+    "thumbnail",
+    "small",
+    "medium",
+    "large",
+];
 const VIDEO_TASKS_VALUES$1 = ["compressed", "thumbnail"];
 z.enum(VIDEO_TASKS_VALUES$1);
 z.enum(IMAGE_SIZES_VALUES$1);
@@ -4564,12 +4569,29 @@ const UPLOAD_PATHS = {
     FINISH_UPLOAD: "finishMultipartUpload",
     CANCEL_UPLOAD: "cancelUpload",
     DELETE_UPLOAD: "deleteUpload",
+    UPLOAD_SINGLE_FILE: "upload",
 };
 /**
 |--------------------------------------------------
 | Helper Functions
 |--------------------------------------------------
 */
+const MIME_TYPE_MAP = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    qt: "video/quicktime",
+};
+/**
+|--------------------------------------------------
+| Make a File Path
+|--------------------------------------------------
+*/
+function createFilePath(marketId, saleId, lotId, attributeId, fileName) {
+    return `/${marketId}/${saleId}/${lotId}/${attributeId}/${fileName}`;
+}
 const getHeaders = (mimeType, bucket = "raw", token) => {
     const headers = new Headers();
     headers.append("mbtype", bucket);
@@ -4591,7 +4613,7 @@ const startUpload = async ({ fileName, fileMimeType, fileExtension, token, optio
     var _a;
     const headers = getHeaders(fileMimeType, (_a = options.options) === null || _a === void 0 ? void 0 : _a.bucket, token);
     const formData = new FormData();
-    const filePath = `${options.marketId}/${options.saleId}/${options.lotId}/${options.attributeId}/${fileName}.${fileExtension}`;
+    const filePath = createFilePath(options.marketId, options.saleId, options.lotId, options.attributeId, `${fileName}.${fileExtension}`);
     formData.append("filePath", filePath);
     headers.append("Authorization", `Bearer ${token}`);
     let uploadIdResponse = await fetch(new URL(`${BASE_CF_URL}/${UPLOAD_PATHS.START_UPLOAD}`), {
@@ -4758,7 +4780,7 @@ const deleteUpload = async (fileUrl, token) => {
  * @returns {Promise<MediaFinishUploadResponse>}
  * @throws {Error} When upload fails
  */
-const uploadFile = async (input, token) => {
+const uploadMultipartFile = async (input, token) => {
     var _a, _b, _c, _d, _e;
     let uploadId = "";
     let filePath = "";
@@ -4862,12 +4884,61 @@ const uploadFile = async (input, token) => {
         throw new Error("Upload failed and canceled " + error);
     }
 };
+const uploadSingleFile = async (input, token) => {
+    const { file, filePath, uploadConfig } = input;
+    let fileMimeType = "";
+    let destinationPath = "";
+    let fileName = "";
+    let fileExtension = "";
+    if (!filePath && !file) {
+        throw new Error("Either filePath or file must be provided");
+    }
+    if (filePath && file) {
+        throw new Error("Only one of filePath or file can be provided");
+    }
+    // We perform a copy form one file to another
+    if (filePath) {
+        fileName = filePath.split("/").pop() || "";
+        fileExtension = fileName.split(".").pop() || "";
+        fileMimeType = MIME_TYPE_MAP[fileExtension] || "";
+        destinationPath = createFilePath(uploadConfig.marketId, uploadConfig.saleId, uploadConfig.lotId, uploadConfig.attributeId, `${fileName}`);
+    }
+    // We upload a single File
+    if (file) {
+        fileName = file.name.replace(/\.[^/.]+$/, "");
+        fileExtension = file.name.split(".").pop() || "";
+        fileMimeType = file.type;
+        destinationPath = createFilePath(uploadConfig.marketId, uploadConfig.saleId, uploadConfig.lotId, uploadConfig.attributeId, `${fileName}.${fileExtension}`);
+    }
+    // Construct the Fetch Request
+    const uploadUrl = new URL(`${BASE_CF_URL}/${UPLOAD_PATHS.UPLOAD_SINGLE_FILE}`);
+    const headers = new Headers();
+    headers.append("mbtype", "raw");
+    headers.append("Authorization", `Bearer ${token}`);
+    headers.append("mmimetype", fileMimeType);
+    const formData = new FormData();
+    filePath && formData.append("existingFilePath", filePath);
+    destinationPath && formData.append("filePath", destinationPath);
+    file && formData.append("file", file);
+    const uploadResponse = await fetch(uploadUrl, {
+        headers: headers,
+        method: "POST",
+        body: formData,
+    });
+    if (!uploadResponse.ok) {
+        throw new Error("Failed to upload single file");
+    }
+    return (await uploadResponse.json());
+};
 
 // Multipart Upload for Media to the MARTEYE Media Service
 function create$9() {
     const files = {
-        uploadFile: async (input, token) => {
-            return await uploadFile(input, token);
+        uploadSingleFile: async (input, token) => {
+            return await uploadSingleFile(input, token);
+        },
+        uploadMultipartFile: async (input, token) => {
+            return await uploadMultipartFile(input, token);
         },
         deleteFile: async (fileUrl, token) => {
             return await deleteUpload(fileUrl, token);
@@ -5212,5 +5283,238 @@ function createAppManifest(appConfig) {
     };
 }
 
-export { Studio, StudioHeaders, types as StudioTypes, createAppManifest, Studio as default };
+class EarTag {
+    static get countryCodesByNumber() {
+        let reversed = {};
+        for (const key of Object.keys(EarTag.countryCodes)) {
+            reversed[EarTag.countryCodes[key]] = key;
+        }
+        return reversed;
+    }
+    normalisedCountryCode(countryCode) {
+        if (!countryCode || typeof countryCode !== "string") {
+            return null;
+        }
+        switch (countryCode) {
+            case "GB-ENG":
+            case "GB-SCT":
+            case "GB-WLS":
+                return "UK";
+            case "GB-NIR":
+                return "XI";
+            default:
+                return countryCode;
+        }
+    }
+    get raw() {
+        return this._raw;
+    }
+    isEartag() {
+        return this._isEartag;
+    }
+    get isoCountryCode() {
+        return this._isoCountryCode;
+    }
+    get nationalIdentifier() {
+        return this._nationalIdentifier;
+    }
+    // private constructor
+    constructor(input, fallbackCountryCode) {
+        // readonly properties
+        this._isEartag = false;
+        fallbackCountryCode = this.normalisedCountryCode(fallbackCountryCode);
+        let workingInput = input.replace(/\s/g, "").replace(/[^ -~]+/g, "");
+        this._raw = workingInput; // Store the initial cleaned input. May get updated if prefix is added.
+        // Part 1: Handle explicit country codes (alpha or numeric) in the input string
+        let parsedCountryCode;
+        let parsedNationalIdentifier;
+        // 1a. Alpha prefix
+        if (workingInput.length > 2 && /^[A-Z]{2}/.test(workingInput)) {
+            const alphaCode = workingInput.slice(0, 2);
+            const numericCode = EarTag.countryCodes[alphaCode];
+            if (numericCode) {
+                // Replace alpha with numeric for further parsing
+                workingInput = numericCode + workingInput.slice(2);
+                this._raw = workingInput; // Update _raw as it now contains numeric country code
+            }
+            // If unknown alpha, workingInput remains as is, will be handled by numeric check or fallback
+        }
+        // 1b. Numeric country code (already in workingInput, or converted from alpha)
+        const countryPattern = "(372|826|899|528|250|276|056)";
+        const regex12 = new RegExp(`^[0-9]{0,7}(${countryPattern})([0-9]{7})([0-9]{5})`);
+        let match12 = regex12.exec(workingInput);
+        if (match12) {
+            parsedCountryCode = match12[1];
+            parsedNationalIdentifier = `${match12[3]}${match12[4]}`;
+        }
+        else {
+            const regex11 = new RegExp(`^[0-9]{0,7}(${countryPattern})([0-9]{6})([0-9]{5})`);
+            let match11 = regex11.exec(workingInput);
+            if (match11) {
+                parsedCountryCode = match11[1];
+                parsedNationalIdentifier = `${match11[3]}${match11[4]}`;
+            }
+        }
+        // Part 2: If no country code parsed yet, try fallback
+        if (!parsedCountryCode && fallbackCountryCode) {
+            const numericFallback = EarTag.countryCodes[fallbackCountryCode];
+            if (numericFallback) {
+                // `workingInput` at this point is the original input (cleaned, no recognized country code)
+                // Assume `workingInput` is the national identifier part (must be 11 or 12 digits)
+                if (workingInput.length === 12 || workingInput.length === 11) {
+                    parsedCountryCode = numericFallback;
+                    parsedNationalIdentifier = workingInput;
+                    // Update _raw to reflect the tag as if it had the country code
+                    this._raw = numericFallback + workingInput;
+                }
+            }
+        }
+        // Part 3: Finalize and set properties
+        if (parsedCountryCode && parsedNationalIdentifier) {
+            this._isoCountryCode = parsedCountryCode;
+            if (parsedNationalIdentifier.length === 11) {
+                // Pad 11-digit national ID to 12-digits by prepending "0"
+                this._nationalIdentifier = "0" + parsedNationalIdentifier;
+            }
+            else if (parsedNationalIdentifier.length === 12) {
+                this._nationalIdentifier = parsedNationalIdentifier;
+            }
+            else {
+                // This case should ideally not be reached if lengths are checked properly before.
+                this._isEartag = false;
+                return;
+            }
+            this._isEartag = true;
+        }
+        else {
+            this._isEartag = false;
+        }
+    }
+    static parse(str, fallbackCountryCode) {
+        return new EarTag(str, fallbackCountryCode);
+    }
+    static format(str, marketCountry) {
+        let t = EarTag.parse(str, marketCountry);
+        if (t.isEartag()) {
+            return t.toString();
+        }
+        return null;
+    }
+    toString() {
+        if (!this._isEartag) {
+            return "Invalid EarTag";
+        }
+        return `${EarTag.countryCodesByNumber[this.isoCountryCode]} ${this.nationalIdentifier.slice(0, 7)} ${this.nationalIdentifier.slice(7)}`;
+    }
+    isISO24631() {
+        return EarTag.regexISO24631.test(this._raw);
+    }
+    toISO24631() {
+        if (!this.isISO24631()) {
+            return "Not a ISO24631 EarTag";
+        }
+        // ISO 24631 Formatting for movements
+        const res = EarTag.regexISO24631.exec(this._raw);
+        return `${res[1]} ${res[2]} ${res[3]} ${res[4]} ${res[5]} ${res[6]} ${res[7]} ${res[8]}`;
+    }
+}
+EarTag.regexISO24631 = /^([0-9]{1})([0-9]{1})([0-9]{2})([0-9]{2})([0-9]{1})(372|826|899|528|250|276)([0-9]{7})([0-9]{5})/;
+EarTag.countryCodes = {
+    IE: "372",
+    UK: "826",
+    XI: "899",
+    NL: "528",
+    FR: "250",
+    DE: "276",
+    BE: "056",
+};
+
+function lotComparator(a, b) {
+    const aMatch = a.lotNumber.match(/^(\d+)(\D*)$/);
+    const bMatch = b.lotNumber.match(/^(\d+)(\D*)$/);
+    // If neither matches the pattern, fall back to string comparison
+    if (!aMatch && !bMatch) {
+        return a.lotNumber.localeCompare(b.lotNumber);
+    }
+    // If only one matches, the one with numbers comes after
+    if (!aMatch)
+        return -1;
+    if (!bMatch)
+        return 1;
+    // Handle cases with numbers
+    const aNum = parseInt(aMatch[1], 10);
+    const bNum = parseInt(bMatch[1], 10);
+    // Compare numeric parts first
+    if (aNum !== bNum)
+        return aNum - bNum;
+    // Get alphabetic suffixes (or empty string if none)
+    const aAlpha = (aMatch === null || aMatch === void 0 ? void 0 : aMatch[2]) || "";
+    const bAlpha = (bMatch === null || bMatch === void 0 ? void 0 : bMatch[2]) || "";
+    // Compare by length first (shorter comes first)
+    if (aAlpha.length !== bAlpha.length)
+        return aAlpha.length - bAlpha.length;
+    // Then compare alphabetically
+    return aAlpha.localeCompare(bAlpha);
+}
+function sortByLotNumber(lots) {
+    return [...lots].sort(lotComparator);
+}
+/***
+ * Generate the next lot number in a sequence:
+ */
+function nextLotNumber(previousLotNumber) {
+    const match = previousLotNumber.match(/^(\d+)(\D*)$/);
+    if (match) {
+        // Has numeric part
+        const numPart = parseInt(match[1], 10);
+        const alphaPart = match[2];
+        if (alphaPart === "") {
+            // Just a number: 1 -> 2
+            return (numPart + 1).toString();
+        }
+        else {
+            // Alphanumeric: increment the alpha part
+            const nextAlpha = incrementAlphaSequence(alphaPart);
+            return numPart + nextAlpha;
+        }
+    }
+    else {
+        // Pure alphabetic: A -> B, Z -> AA, etc.
+        return incrementAlphaSequence(previousLotNumber);
+    }
+}
+function incrementAlphaSequence(alpha) {
+    if (alpha === "") {
+        return "A";
+    }
+    // Convert to uppercase for consistent handling
+    alpha = alpha.toUpperCase();
+    // Check if we're at the end of sequence (all Z's)
+    if (alpha === "Z".repeat(alpha.length)) {
+        // Z -> AA, ZZ -> AAA, etc.
+        return "A".repeat(alpha.length + 1);
+    }
+    // Convert string to array for easier manipulation
+    let chars = alpha.split("");
+    let carry = true;
+    // Start from the rightmost character and work backwards
+    for (let i = chars.length - 1; i >= 0 && carry; i--) {
+        if (chars[i] === "Z") {
+            chars[i] = "A";
+            // carry remains true
+        }
+        else {
+            // Increment the character
+            chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1);
+            carry = false;
+        }
+    }
+    // If we still have carry, prepend an A
+    if (carry) {
+        chars.unshift("A");
+    }
+    return chars.join("");
+}
+
+export { EarTag, Studio, StudioHeaders, types as StudioTypes, createAppManifest, Studio as default, lotComparator, nextLotNumber, sortByLotNumber };
 //# sourceMappingURL=index.esm.js.map