@scayle/storefront-product-detail 1.5.6 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # @scayle/storefront-product-detail
 
+## 1.6.0
+
+### Minor Changes
+
+- Added utility functions `sellableTimeframeStartsInFuture`, `sellableTimeframeEndsInPast`, and `isInSellableTimeframe` for checking whether a product's sellable timeframe is currently active. Also introduced the `useSellableTimeFrame()` composable for convenient access to these checks within your components.
+
+  **Usage Examples:**
+
+  **`sellableTimeframeStartsInFuture`:**
+
+  ```ts
+  import { sellableTimeframeStartsInFuture } from '@scayle/storefront-product-detail'
+
+  // Example timeframe
+  const timeframe = {
+    sellableFrom: '2099-01-01T00:00:00Z',
+    sellableTo: '2100-01-01T00:00:00Z',
+  }
+
+  const inFuture = sellableTimeframeStartsInFuture(timeframe)
+  console.log(inFuture) // true if current date is before 2099-01-01
+  ```
+
+  **`sellableTimeframeEndsInPast`:**
+
+  ```ts
+  import { sellableTimeframeEndsInPast } from '@scayle/storefront-product-detail'
+
+  const timeframe = {
+    sellableFrom: '2018-01-01T00:00:00Z',
+    sellableTo: '2020-01-01T00:00:00Z',
+  }
+
+  const ended = sellableTimeframeEndsInPast(timeframe)
+  console.log(ended) // true if current date is after 2020-01-01
+  ```
+
+  **`isInSellableTimeframe`:**
+
+  ```ts
+  import { isInSellableTimeframe } from '@scayle/storefront-product-detail'
+
+  const timeframe = {
+    sellableFrom: '2023-01-01T00:00:00Z',
+    sellableTo: '2025-01-01T00:00:00Z',
+  }
+
+  const active = isInSellableTimeframe(timeframe)
+  console.log(active) // true if current date is between 2023-01-01 and 2025-01-01
+  ```
+
+  **`useSellableTimeFrame`:**
+
+  ```ts
+  import { useSellableTimeFrame } from '@scayle/storefront-product-detail'
+
+  const timeframe = {
+    sellableFrom: '2023-01-01T00:00:00Z',
+    sellableTo: '2025-01-01T00:00:00Z',
+  }
+  const {
+    isInSellableTimeframe,
+    sellableTimeframeStartsInFuture,
+    sellableTimeframeEndsInPast,
+  } = useSellableTimeFrame(timeframe)
+
+  console.log(isInSellableTimeframe) // true if the timeframe is active
+  console.log(sellableTimeframeStartsInFuture) // true if the time frame starts in the future
+  console.log(sellableTimeframeEndsInPast) // true if the timeframe ended in the past
+  ```
+
 ## 1.5.6
 
 ### Patch Changes

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-product-detail",
   "configKey": "product-detail",
-  "version": "1.5.6",
+  "version": "1.6.0",
   "compatibility": {
     "bridge": false,
     "nuxt": ">=3.13"

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { defineNuxtModule, createResolver, addImportsDir } from '@nuxt/kit';
 
 const PACKAGE_NAME = "@scayle/storefront-product-detail";
-const PACKAGE_VERSION = "1.5.6";
+const PACKAGE_VERSION = "1.6.0";
 const module$1 = defineNuxtModule({
   meta: {
     name: PACKAGE_NAME,

package/dist/runtime/composables/useSellableTimeFrame.d.ts

@@ -0,0 +1,25 @@
+import type { Product } from '@scayle/storefront-nuxt';
+/**
+ * Helper composable to check a sellable timeframes current status.
+ *
+ * @param timeFrame The sellable timeframe to check
+ * @param now (optional) The current date and time used to check if the timeframe is active
+ * @returns An object containing different computed values indicating the current status of the sellable timeframe
+ */
+export declare function useSellableTimeFrame(timeFrame: Product['sellableTimeframe'], now?: Date): {
+    /**
+     * Whether the sellable timeframe is currently active.
+     * Returns true if the sellable timeframe is currently active, false otherwise.
+     */
+    isInSellableTimeframe: import("vue").ComputedRef<boolean>;
+    /**
+     * Whether the sellable timeframe starts in the future.
+     * Returns true if the sellable timeframe starts in the future, false otherwise.
+     */
+    sellableTimeframeStartsInFuture: import("vue").ComputedRef<boolean>;
+    /**
+     * Whether the sellable timeframe ends in the past.
+     * Returns true if the sellable timeframe ends in the past, false otherwise.
+     */
+    sellableTimeframeEndsInPast: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useSellableTimeFrame.js

@@ -0,0 +1,31 @@
+import { computed } from "vue";
+import {
+  isInSellableTimeframe,
+  sellableTimeframeEndsInPast,
+  sellableTimeframeStartsInFuture
+} from "../utils/product.js";
+export function useSellableTimeFrame(timeFrame, now = /* @__PURE__ */ new Date()) {
+  return {
+    /**
+     * Whether the sellable timeframe is currently active.
+     * Returns true if the sellable timeframe is currently active, false otherwise.
+     */
+    isInSellableTimeframe: computed(
+      () => isInSellableTimeframe(timeFrame, now)
+    ),
+    /**
+     * Whether the sellable timeframe starts in the future.
+     * Returns true if the sellable timeframe starts in the future, false otherwise.
+     */
+    sellableTimeframeStartsInFuture: computed(
+      () => sellableTimeframeStartsInFuture(timeFrame, now)
+    ),
+    /**
+     * Whether the sellable timeframe ends in the past.
+     * Returns true if the sellable timeframe ends in the past, false otherwise.
+     */
+    sellableTimeframeEndsInPast: computed(
+      () => sellableTimeframeEndsInPast(timeFrame, now)
+    )
+  };
+}

package/dist/runtime/utils/product.d.ts

@@ -1,4 +1,4 @@
-import type { AdvancedAttribute } from '@scayle/storefront-nuxt';
+import type { AdvancedAttribute, Product } from '@scayle/storefront-nuxt';
 /**
  * Extracts and returns an array of product IDs from an advanced attribute.
  *
@@ -67,3 +67,31 @@ import type { AdvancedAttribute } from '@scayle/storefront-nuxt';
  * ```
  */
 export declare const getCombineWithProductIds: (attribute?: AdvancedAttribute) => number[];
+/**
+ * Checks if a timeframe is currently active.
+ * A timeframe is considered active if the current time is between the start and end date.
+ * If the timeframe is not set, it is considered active.
+ *
+ * @param timeframe The timeframe to check
+ * @param now (optional) The current date and time used to check if the timeframe is active
+ * @returns True if the timeframe is active, false otherwise
+ */
+export declare function isInSellableTimeframe(timeframe: Product['sellableTimeframe'], now?: Date): boolean;
+/**
+ * Checks if a sellable timeframe starts in the future.
+ * If the timeframe is not set, the timeframe is considered to be currently started.
+ *
+ * @param timeframe The timeframe to check
+ * @param now (optional) The current date and time used to check if the timeframe is active
+ * @returns True if the timeframe starts in the future, false otherwise
+ */
+export declare function sellableTimeframeStartsInFuture(timeframe: Product['sellableTimeframe'], now?: Date): boolean;
+/**
+ * Checks if a sellable timeframe ends in the past.
+ * If the timeframe or the sellableTo date is not set, the timeframe is considered to be currently active.
+ *
+ * @param timeframe The timeframe to check
+ * @param now (optional) The current date and time used to check if the timeframe is active
+ * @returns True if the timeframe ends in the past, false otherwise
+ */
+export declare function sellableTimeframeEndsInPast(timeframe: Product['sellableTimeframe'], now?: Date): boolean;

package/dist/runtime/utils/product.js

@@ -5,3 +5,23 @@ export const getCombineWithProductIds = (attribute) => {
   }
   return getFlattenedAdvancedAttribute(attribute.values)?.map((item) => Number.parseInt(item.value))?.filter((value) => !Number.isNaN(value)) || [];
 };
+export function isInSellableTimeframe(timeframe, now = /* @__PURE__ */ new Date()) {
+  if (!timeframe || !timeframe.sellableFrom && !timeframe.sellableTo) {
+    return true;
+  }
+  return !sellableTimeframeStartsInFuture(timeframe, now) && !sellableTimeframeEndsInPast(timeframe, now);
+}
+export function sellableTimeframeStartsInFuture(timeframe, now = /* @__PURE__ */ new Date()) {
+  if (!timeframe || !timeframe.sellableFrom) {
+    return false;
+  }
+  const sellableFrom = new Date(timeframe.sellableFrom);
+  return sellableFrom > now;
+}
+export function sellableTimeframeEndsInPast(timeframe, now = /* @__PURE__ */ new Date()) {
+  if (!timeframe || !timeframe.sellableTo) {
+    return false;
+  }
+  const sellableTo = new Date(timeframe.sellableTo);
+  return sellableTo < now;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-product-detail",
-  "version": "1.5.6",
+  "version": "1.6.0",
   "description": "Collection of essential composables and utilities to work with product detail",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -40,25 +40,25 @@
     "@nuxt/kit": "3.20.0",
     "@nuxt/module-builder": "1.0.2",
     "@nuxt/schema": "3.20.0",
-    "@nuxt/test-utils": "3.20.1",
-    "@types/node": "22.19.1",
-    "@vitest/coverage-v8": "4.0.14",
+    "@nuxt/test-utils": "3.21.0",
+    "@types/node": "22.19.2",
+    "@vitest/coverage-v8": "4.0.15",
     "@vueuse/core": "13.9.0",
     "dprint": "0.50.2",
-    "eslint-formatter-gitlab": "6.0.1",
+    "eslint-formatter-gitlab": "7.0.1",
     "eslint": "9.39.1",
-    "happy-dom": "20.0.10",
+    "happy-dom": "20.0.11",
     "nuxt": "3.20.0",
-    "publint": "0.3.15",
+    "publint": "0.3.16",
     "schema-dts": "1.1.5",
     "typescript": "5.9.3",
     "unbuild": "3.6.1",
-    "vitest": "4.0.14",
+    "vitest": "4.0.15",
     "vue-router": "4.6.3",
-    "vue-tsc": "3.1.5",
+    "vue-tsc": "3.1.8",
     "vue": "3.5.25",
-    "@scayle/eslint-config-storefront": "4.7.14",
-    "@scayle/storefront-nuxt": "8.53.3",
+    "@scayle/eslint-config-storefront": "4.7.17",
+    "@scayle/storefront-nuxt": "8.56.0",
     "@scayle/vitest-config-storefront": "1.0.0"
   },
   "scripts": {