@shushed/helpers 0.0.203 → 0.0.204

package/dist/cjs/src-public/airtable.js

@@ -62,6 +62,7 @@ class AirtableHelper extends runtime_1.default {
                         fieldsToMergeOn: (options.fieldsToMergeOn ?? [this.primaryKeyFieldName]).map(x => this.dictionary[x] || x),
                     },
                     returnFieldsByFieldId: true,
+                    typecast: options.typecast || false,
                     records: currentBatch.map(x => {
                         const recordId = x.$recordId;
                         const fieldsWithoutRecordId = { ...x };

package/dist/cjs/src-public/centra.js

@@ -73,6 +73,14 @@ class CentraHelper extends env_1.default {
                 errors.push(...userErrors.map((x) => ({ message: x.message, path: x.path })));
                 return { errors, limitExceeded: response.status === 429 };
             }
+            if (resp.data && typeof resp.data === 'object') {
+                for (const key in resp.data) {
+                    if (resp.data[key] && typeof resp.data[key] === 'object' && 'userErrors' in resp.data[key] && Array.isArray(resp.data[key].userErrors) && resp.data[key].userErrors.length > 0) {
+                        errors.push(...resp.data[key].userErrors.map((x) => ({ message: x.message, path: x.path })));
+                        return { errors, limitExceeded: response.status === 429 };
+                    }
+                }
+            }
         }
         if (response.status === 429) {
             resp.limitExceeded = true;
@@ -323,7 +331,7 @@ class CentraHelper extends env_1.default {
         } while (hasNextPage);
         return result;
     }
-    async fetchCentraMarkets(externalIds) {
+    async fetchCentraMarkets() {
         const result = [];
         const limit = 200;
         let page = 0;
@@ -333,15 +341,15 @@ class CentraHelper extends env_1.default {
                 method: 'POST',
                 body: JSON.stringify({
                     query: `
-                        query GetMarkets($limit: Int, $page: Int${externalIds ? `, $externalIds: MarketsFilter` : ''}) {
-                            markets(${externalIds ? `where: $externalIds, ` : ''}limit: $limit, page: $page) {
+                        query GetMarkets($limit: Int, $page: Int) {
+                            markets(limit: $limit, page: $page) {
                                 id
                                 externalId
                                 name
                             }
                         }
                         `,
-                    variables: { page: page, limit: limit, externalIds: { externalId: externalIds } }
+                    variables: { page: page, limit: limit }
                 })
             });
             if (CentraHelper.isCentraErrors(data)) {
@@ -471,7 +479,7 @@ class CentraHelper extends env_1.default {
                 nextCursor = null;
             }
             if (data && data.data?.productConnection?.edges?.length) {
-                for (let i = data.data.productConnection.edges.length; i < styleIds.length; i++) {
+                for (let i = 0; i < data.data.productConnection.edges.length; i++) {
                     const { node } = data.data.productConnection.edges[i];
                     result[node.externalId] = node;
                 }
@@ -497,16 +505,15 @@ class CentraHelper extends env_1.default {
                                 edges {
                                     node {
                                         id
-                                        externalId
                                         status
-                                        url
+                                        uri
                                         metaTitle
                                         metaDescription
                                         name
                                         categories {
                                             id
                                             name
-                                            url
+                                            uri
                                             isTopCategory
                                         }
                                         markets {
@@ -518,7 +525,7 @@ class CentraHelper extends env_1.default {
                                             externalId
                                             status
                                         }
-                                        productVariant {
+                                        productVariants {
                                             id
                                             externalId
                                             status
@@ -565,8 +572,8 @@ class CentraHelper extends env_1.default {
                 for (let i = 0; i < edges.length; i++) {
                     const { node } = edges[i];
                     if (inputIdType === 'variant') {
-                        result[+node.productVariant[0].id] = [];
-                        result[+node.productVariant[0].id].push(node);
+                        result[+node.productVariants[0].id] = [];
+                        result[+node.productVariants[0].id].push(node);
                     }
                     else {
                         result[+node.product.id] = [];
@@ -790,59 +797,45 @@ class CentraHelper extends env_1.default {
         }
         return Object.assign({}, pricelistInCache, pricelistToSet);
     }
-    async getCentraMarkets(externalIds, alwaysFetch = false) {
-        if (externalIds && !externalIds.length) {
-            return {};
-        }
+    async getCentraMarkets(alwaysFetch = false) {
         let marketInCache = {};
-        let dedupedExternalIds = [];
+        let dedupedMarketNamesInCache = [];
         let marketsToFetch = null;
         if (!alwaysFetch) {
-            if (!externalIds) {
-                externalIds = (await this.get(this.getCacheKeyForMarkets(), 'env', {
-                    isEphemeral: true,
-                    encrypted: false,
-                }).then(x => x ? JSON.parse(x) : null));
-            }
-            if (externalIds) {
-                dedupedExternalIds = externalIds.filter((x, index, self) => self.indexOf(x) === index);
-                marketInCache = Object.fromEntries(Object.entries(await this.get(dedupedExternalIds.map(x => this.getCacheKeyForMarket(x)), 'env', {
+            const marketNamesInCache = (await this.get(this.getCacheKeyForMarkets(), 'env', {
+                isEphemeral: true,
+                encrypted: false,
+            }).then(x => x ? JSON.parse(x) : null));
+            if (marketNamesInCache) {
+                dedupedMarketNamesInCache = marketNamesInCache.filter((x, index, self) => self.indexOf(x) === index);
+                marketInCache = Object.fromEntries(Object.entries(await this.get(dedupedMarketNamesInCache.map(x => this.getCacheKeyForMarket(x)), 'env', {
                     isEphemeral: true,
                     encrypted: false,
                 })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value));
-                marketsToFetch = dedupedExternalIds.filter(x => !marketInCache[x]);
+                marketsToFetch = dedupedMarketNamesInCache.filter(x => !marketInCache[x]);
             }
         }
         const marketToSet = {};
         if (!marketsToFetch || marketsToFetch.length) {
-            const markets = await this.fetchCentraMarkets(marketsToFetch);
+            const markets = await this.fetchCentraMarkets();
             if (CentraHelper.isCentraErrors(markets)) {
-                if (marketsToFetch) {
-                    for (const marketExternalId of marketsToFetch) {
-                        marketToSet[marketExternalId] = new Error(`Failed to fetch market ${marketExternalId}: ${markets.errors.map((x) => x.message).join(', ')}`);
-                    }
-                }
-                else {
-                    return new Error(`Failed to fetch markets: ${markets.errors.map((x) => x.message).join(', ')}`);
-                }
+                return new Error(`Failed to fetch markets: ${markets.errors.map((x) => x.message).join(', ')}`);
             }
             else {
                 for (const market of markets) {
-                    marketToSet[market.externalId] = market;
+                    marketToSet[market.name] = market;
                 }
                 await this.set(Object.entries(marketToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForMarket(key), value: JSON.stringify(value) })), 'env', {
                     ephemeralMs: CACHE_EXPIRATION_MS,
                     encrypted: false,
                 });
-                if (!marketsToFetch) {
-                    await this.set([{
-                            name: this.getCacheKeyForMarkets(),
-                            value: JSON.stringify(Object.keys(marketToSet)),
-                        }], 'env', {
-                        ephemeralMs: CACHE_EXPIRATION_MS,
-                        encrypted: false,
-                    });
-                }
+                await this.set([{
+                        name: this.getCacheKeyForMarkets(),
+                        value: JSON.stringify(Object.keys(marketToSet)),
+                    }], 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
             }
         }
         return Object.assign({}, marketInCache, marketToSet);

package/dist/cjs/src-public/dato.js

@@ -72,11 +72,6 @@ class DatoHelper extends runtime_1.default {
         return response;
     }
     async createAssetFromUpload(uploadId, opts, uploadCollectionId) {
-        const normalizedTags = Array.isArray(opts.tags) && opts.tags.length > 0
-            ? opts.tags
-            : ["integrations"];
-        const safeTitle = opts.title && opts.title.trim().length > 0 ? opts.title : "untitled";
-        const safeAlt = opts.alt && opts.alt.trim().length > 0 ? opts.alt : safeTitle;
         const body = {
             data: {
                 type: 'upload',
@@ -85,35 +80,13 @@ class DatoHelper extends runtime_1.default {
                     author: opts.author,
                     copyright: opts.copyright,
                     notes: opts.notes || null,
-                    title: safeTitle,
-                    alt: safeAlt,
                     default_field_metadata: {
-                        "en-GB": {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
-                        },
                         en: {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
-                        },
-                        "en-US": {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
+                            title: opts.title,
+                            alt: opts.alt,
                         }
                     },
-                    tags: normalizedTags || [],
+                    tags: opts.tags || [],
                 },
             },
         };
@@ -182,119 +155,8 @@ class DatoHelper extends runtime_1.default {
         this.logging.error(timeoutMsg);
         throw new Error(timeoutMsg);
     }
-    updateUpload = async (options) => {
-        try {
-            this.logging.log(`Starting update upload - ${JSON.stringify(options)}`);
-            if (!options.id)
-                throw new Error("updateUpload requires 'id' in options");
-            const safeTitle = options.title && options.title.trim().length > 0
-                ? options.title.trim()
-                : options.filename?.trim().split(".")[0] || "untitled";
-            const safeAlt = options.alt && options.alt.trim().length > 0
-                ? options.alt.trim()
-                : safeTitle;
-            const normalizedTags = Array.isArray(options.tags) && options.tags.length > 0
-                ? options.tags
-                : ["integrations"];
-            const body = {
-                data: {
-                    type: "upload",
-                    id: options.id,
-                    attributes: {
-                        author: options.author,
-                        copyright: options.copyright,
-                        tags: normalizedTags,
-                        notes: options.notes || null,
-                        default_field_metadata: {
-                            "en-GB": {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                            en: {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                            "en-US": {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            if (options.uploadCollectionId) {
-                body.data.relationships = {
-                    upload_collection: {
-                        data: {
-                            type: "upload_collection",
-                            id: options.uploadCollectionId,
-                        },
-                    },
-                };
-            }
-            const response = await fetch(`${this.baseUrl}/uploads/${options.id}`, {
-                method: "PATCH",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                this.logging.error(`Failed to update upload: ${response.statusText} - ${errorText}`);
-                throw new Error(`Failed to update upload: ${response.statusText} - ${errorText}`);
-            }
-            const updated = await response.json();
-            if (Array.isArray(updated.data) && updated.data[0]?.type === "api_error") {
-                const errorCode = updated.data[0].attributes?.code || "UNKNOWN_ERROR";
-                const errorMsg = `DatoCMS API error: ${errorCode}`;
-                this.logging.error(errorMsg);
-                throw new Error(errorMsg);
-            }
-            if (updated.data?.type === "job") {
-                this.logging.log(`Waiting for job completion: ${updated.data.id}`);
-                const jobPayload = await this.waitForJobCompletion(updated.data.id);
-                const assetId = jobPayload?.data?.id;
-                const assetUrl = jobPayload?.data?.attributes?.url;
-                if (!assetId || !assetUrl) {
-                    throw new Error(`Job completed but payload missing expected fields: ${JSON.stringify(jobPayload)}`);
-                }
-                this.logging.log(`Job completed for upload: ${assetId}`);
-                return { success: true, assetId, upload: assetUrl };
-            }
-            if (updated.data?.type === "upload") {
-                const { id, attributes } = updated.data;
-                this.logging.log(`Upload updated successfully: ${id}`);
-                return { success: true, assetId: id, upload: attributes.url };
-            }
-            const errMsg = `Unexpected update response: ${JSON.stringify(updated)}`;
-            this.logging.error(errMsg);
-            throw new Error(errMsg);
-        }
-        catch (err) {
-            const msg = err?.message ?? JSON.stringify(err);
-            this.logging.error(`[updateUpload] failed: ${msg}`);
-            throw new Error(msg);
-        }
-    };
     async uploadFromUrl(options) {
-        const { url, filename, uploadCollectionId, skipCreationIfAlreadyExists } = options;
+        const { url, filename, uploadCollectionId } = options;
         this.logging.log(`Starting upload from URL: ${url}`);
         const fileResponse = await fetch(url);
         if (!fileResponse.ok) {
@@ -302,43 +164,9 @@ class DatoHelper extends runtime_1.default {
             this.logging.error(errorMsg);
             throw new Error(errorMsg);
         }
-        let finalFilename = filename || path_1.default.basename(new URL(url).pathname) ||
-            `bs-${this.triggerId}-${Date.now()}`;
-        if (filename && !path_1.default.extname(finalFilename)) {
-            const urlObj = new URL(url);
-            const pathname = urlObj.pathname;
-            if (pathname.includes(".")) {
-                const urlExtension = path_1.default.extname(pathname);
-                if (urlExtension) {
-                    finalFilename += urlExtension;
-                }
-            }
-            if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
-                const ext = (0, mime_types_1.extension)(fileResponse.headers.get('content-type'));
-                if (typeof ext === "string" && ext.length > 0) {
-                    finalFilename += `.${ext}`;
-                }
-            }
-        }
-        else if (!filename) {
-            if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
-                const ext = (0, mime_types_1.extension)(fileResponse.headers.get('content-type'));
-                if (typeof ext === "string" && ext.length > 0) {
-                    finalFilename += `.${ext}`;
-                }
-            }
-        }
-        if (skipCreationIfAlreadyExists) {
-            const existing = await this.findUploadByFilename(finalFilename);
-            if (existing) {
-                this.logging.log(`Skipping upload: existing asset found for "${finalFilename}"`);
-                return {
-                    success: true,
-                    assetId: existing.id,
-                    upload: existing.attributes.url,
-                    skipped: true,
-                };
-            }
+        let finalFilename = filename || path_1.default.basename(new URL(url).pathname) || 'bs-' + this.triggerId + '-' + new Date().getTime();
+        if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
+            finalFilename += `.${(0, mime_types_1.extension)(fileResponse.headers.get('content-type'))}`;
         }
         const uploadRequest = await this.requestUploadParameters(finalFilename);
         const uploadId = uploadRequest.data.id;
@@ -355,7 +183,6 @@ class DatoHelper extends runtime_1.default {
             success: true,
             upload: assetPayload.data.attributes.url,
             assetId: assetPayload.data.id,
-            skipped: false,
         };
     }
     async uploadFromFile(options) {
@@ -437,14 +264,7 @@ class DatoHelper extends runtime_1.default {
     }
     async findUploadByFilename(filename) {
         try {
-            if (!filename || typeof filename !== 'string') {
-                this.logging.log(`findUploadByFilename called with invalid filename: ${String(filename)}`);
-                return null;
-            }
-            const normalizedTarget = filename.trim().toLowerCase().replace(/\.[^.]+$/, '');
-            const query = encodeURIComponent(normalizedTarget);
-            this.logging.log(`Searching uploads with query="${normalizedTarget}" for filename="${filename}"`);
-            const response = await fetch(`${this.baseUrl}/uploads?filter[query]=${query}&page[limit]=100`, {
+            const response = await fetch(`${this.baseUrl}/uploads?filter[filename]=${encodeURIComponent(filename)}`, {
                 headers: {
                     'Authorization': `Bearer ${this.apiToken}`,
                     'X-Api-Version': '3',
@@ -461,32 +281,10 @@ class DatoHelper extends runtime_1.default {
                 this.logging.error(`Failed to parse JSON in findUploadByFilename: ${err.message}`);
                 return null;
             });
-            const uploads = data?.data || [];
-            if (!uploads.length) {
-                this.logging.log(`No uploads returned for query="${normalizedTarget}"`);
-                return null;
-            }
-            const targetFull = filename.trim().toLowerCase();
-            const match = uploads.find((u) => {
-                const storedFull = u?.attributes?.filename?.toLowerCase();
-                if (!storedFull)
-                    return false;
-                if (storedFull === targetFull)
-                    return true;
-                const storedNormalized = storedFull.replace(/\.[^.]+$/, '');
-                if (storedNormalized === normalizedTarget)
-                    return true;
-                return false;
-            });
-            if (match) {
-                this.logging.log(`Found existing upload for "${filename}" -> asset_id=${match.id}, storedFilename=${match.attributes?.filename}`);
-                return match;
-            }
-            this.logging.log(`No exact filename match found among ${uploads.length} uploads for "${filename}" (query="${normalizedTarget}")`);
-            return null;
+            return data?.data?.[0] || null;
         }
         catch (err) {
-            this.logging.error(`Error in findUploadByFilename: ${err?.message ?? String(err)}`);
+            this.logging.error(`Error in findUploadByFilename: ${err.message}`);
             return null;
         }
     }
@@ -601,37 +399,5 @@ class DatoHelper extends runtime_1.default {
             throw err;
         }
     }
-    async updateProductSwatch(productId, uploadId) {
-        try {
-            const res = await fetch(`${this.baseUrl}/items/${productId}`, {
-                method: "PATCH",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-                body: JSON.stringify({
-                    data: {
-                        type: "item",
-                        id: productId,
-                        attributes: {
-                            swatch: { upload_id: uploadId },
-                        },
-                    },
-                }),
-            });
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to update product swatch: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`updateProductSwatch failed: ${err.message}`);
-            throw err;
-        }
-    }
 }
 exports.default = DatoHelper;

package/dist/types/src-public/airtable.d.ts

@@ -44,6 +44,7 @@ declare class AirtableHelper<T extends Record<string, string>, K extends keyof T
     }>, options?: {
         fieldsToMergeOn?: Array<keyof T>;
         primaryKeyWritable?: boolean;
+        typecast?: boolean;
     }, callIdx?: number, collectedResult?: {
         updatedRecords: Array<string>;
         createdRecords: Array<string>;

package/dist/types/src-public/centra.d.ts

@@ -19,19 +19,18 @@ export type BasicCentraProduct = {
 export type BasicCentraDisplay = {
     id: number;
     name: string;
-    externalId: string;
     status: string;
-    url: string;
+    uri: string;
     metaTitle: string;
     metaDescription: string;
     categories: {
         id: number;
         name: string;
-        url: string;
+        uri: string;
         isTopCategory: boolean;
     }[];
     markets: BasicCentraMarket[];
-    productVariant: Array<{
+    productVariants: Array<{
         id: number;
         externalId: string;
         status: string;
@@ -77,7 +76,6 @@ export type BasicCentraCountry = {
 export type BasicCentraMarket = {
     id: number;
     name: string;
-    externalId: string;
 };
 export type BasicCentraVariant = {
     id: number;
@@ -158,14 +156,14 @@ export default class CentraHelper extends EnvEngine {
     fetchCentraWarehouses(externalIds?: string[] | undefined | null): Promise<CentraErrors | Array<BasicCentraWarehouse>>;
     fetchCentraCampaigns(names?: string[] | undefined | null): Promise<CentraErrors | Record<string, BasicCentraCampaign | Error>>;
     fetchPricelists(names?: string[] | undefined | null): Promise<CentraErrors | Array<BasicPricelist>>;
-    fetchCentraMarkets(externalIds?: string[] | undefined | null): Promise<CentraErrors | Array<BasicCentraMarket>>;
+    fetchCentraMarkets(): Promise<CentraErrors | Array<BasicCentraMarket>>;
     fetchCentraSizeCharts(externalIds?: string[] | undefined | null): Promise<CentraErrors | Array<BasicCentraSizeChart>>;
     private fetchCentraProducts;
     private fetchCentraDisplays;
     private fetchCentraVariants;
     getCentraWarehouses(externalIds?: string[] | null | undefined, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraWarehouse>>;
     getCentraPricelists(names?: string[] | null | undefined, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicPricelist>>;
-    getCentraMarkets(externalIds?: string[] | null | undefined, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraMarket>>;
+    getCentraMarkets(alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraMarket>>;
     getCentraCountries(iso2Codes?: string[] | null | undefined, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraCountry>>;
     getCentraSizeCharts(externalIds?: string[] | null | undefined, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraSizeChart>>;
     getCentraProducts(styleIds: string[]): Promise<Error | Record<string, Error | BasicCentraProduct>>;

package/dist/types/src-public/dato.d.ts

@@ -8,16 +8,6 @@ interface UploadResult {
     success: boolean;
     upload: string;
     assetId?: string;
-    skipped?: boolean;
-}
-interface UploadReturn {
-    id: string;
-    type: string;
-    attributes: {
-        url: string;
-        filename: string;
-        [key: string]: any;
-    };
 }
 export default class DatoHelper extends Runtime {
     private apiToken;
@@ -29,21 +19,6 @@ export default class DatoHelper extends Runtime {
     private createAssetFromUpload;
     private checkJobResult;
     private waitForJobCompletion;
-    updateUpload: (options: {
-        id: string;
-        filename?: string;
-        tags: string[];
-        notes?: string;
-        title: string;
-        alt: string;
-        author: string;
-        copyright: string;
-        uploadCollectionId?: string;
-    }) => Promise<{
-        success: boolean;
-        assetId: string;
-        upload: string;
-    }>;
     uploadFromUrl(options: {
         url: string;
         copyright: string;
@@ -78,11 +53,10 @@ export default class DatoHelper extends Runtime {
         quality?: number;
         format?: 'jpg' | 'pjpg' | 'png' | 'webp' | 'avif' | 'gif' | 'jxl' | 'jp2' | 'jxr' | 'json' | 'blurhash' | (string & {});
     }): string;
-    findUploadByFilename(filename: string): Promise<UploadReturn | null>;
+    findUploadByFilename(filename: string): Promise<any>;
     getItemTypeId(apiKey: string): Promise<string>;
     getProductBySku(sku: string): Promise<any>;
     createProduct(sku: string, productTypeId: string): Promise<any>;
     updateProductGallery(productId: string, gallery: any[]): Promise<any>;
-    updateProductSwatch(productId: string, uploadId: string): Promise<any>;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.203",
+  "version": "0.0.204",
   "author": "",
   "license": "UNLICENSED",
   "description": "",