@ikas/component-cli 0.93.0 → 0.94.0

package/templates/create-full/src/utils/bundle.ts

@@ -0,0 +1,70 @@
+import {
+  getSelectedProductVariant,
+  hasProductVariantStock,
+  setBundleProductQuantity,
+  IkasBundleProduct,
+  IkasBundleSettings,
+} from "@ikas/bp-storefront";
+
+export function adjustBundleProductQuantity(bp: IkasBundleProduct): void {
+  if (!bp.product) return;
+
+  const variant = getSelectedProductVariant(bp.product);
+
+  const stock = variant.stock ?? 0;
+  const inStock = hasProductVariantStock(variant);
+
+  if (bp.minQuantity === 0 && !inStock) {
+    setBundleProductQuantity(bp, 0);
+    return;
+  }
+
+  if (stock < 10 && bp.quantity > stock && !variant.sellIfOutOfStock) {
+    setBundleProductQuantity(bp, Math.max(stock, bp.minQuantity ?? 0));
+  }
+}
+
+export function isBundleOutOfStock(
+  bundleSettings: IkasBundleSettings,
+): boolean {
+  const { products, minBundleQuantity, maxBundleQuantity } = bundleSettings;
+
+  // Skip check while bundle product data is still loading
+  const loaded = products.some((bp) => !!bp.product);
+  if (!loaded) return false;
+
+  // A required bundle product (minQuantity !== 0) is out of stock
+  const hasRequiredOutOfStock = products.some((bp) => {
+    if (!bp.product) return false;
+
+    const variant = getSelectedProductVariant(bp.product);
+    const bpHasStock = variant ? hasProductVariantStock(variant) : false;
+
+    return !bpHasStock && bp.minQuantity !== 0;
+  });
+  if (hasRequiredOutOfStock) return true;
+
+  // All bundle products have zero quantity
+  const allZeroQuantity = products.every((p) => p.quantity === 0);
+  if (allZeroQuantity) return true;
+
+  // Total quantity violates bundle-level min/max constraints
+  const totalQuantity = products.reduce((sum, p) => sum + p.quantity, 0);
+  if (minBundleQuantity != null && totalQuantity < minBundleQuantity)
+    return true;
+  if (maxBundleQuantity != null && totalQuantity > maxBundleQuantity)
+    return true;
+
+  // Individual bundle product min/max quantity violations
+  const hasMinQuantityError = products.some(
+    (bp) => bp.minQuantity != null && bp.quantity < bp.minQuantity,
+  );
+  if (hasMinQuantityError) return true;
+
+  const hasMaxQuantityError = products.some(
+    (bp) => bp.maxQuantity != null && bp.quantity > bp.maxQuantity!,
+  );
+  if (hasMaxQuantityError) return true;
+
+  return false;
+}

package/templates/create-full/src/utils/cx.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function cx(...classes: any[]): string {
+  return classes.filter(Boolean).join(" ");
+}

package/templates/create-full/src/utils/fullName.ts

@@ -0,0 +1,6 @@
+export function getFullName(
+  firstName?: string | null,
+  lastName?: string | null
+): string {
+  return [firstName, lastName].filter(Boolean).join(" ");
+}

package/templates/create-full/src/utils/media.ts

@@ -0,0 +1,36 @@
+import type { AspectRatio, ObjectFit, VerticalAlignment } from "../global-types";
+
+const DEFAULT_ASPECT_RATIO: AspectRatio = "Square";
+const DEFAULT_OBJECT_FIT: ObjectFit = "Cover";
+const DEFAULT_VERTICAL_ALIGNMENT: VerticalAlignment = "Middle";
+
+const ASPECT_RATIO_MAP: Record<AspectRatio, string> = {
+  Square: "1 / 1",
+  Portrait: "3 / 4",
+  Landscape: "4 / 3",
+  Video: "16 / 9",
+};
+
+const OBJECT_FIT_MAP: Record<ObjectFit, string> = {
+  Fill: "fill",
+  Cover: "cover",
+  Contain: "contain",
+};
+
+const ALIGNMENT_MAP: Record<VerticalAlignment, string> = {
+  Top: "flex-start",
+  Middle: "center",
+  Bottom: "flex-end",
+};
+
+export function resolveAspectRatio(value?: AspectRatio): string {
+  return ASPECT_RATIO_MAP[value ?? DEFAULT_ASPECT_RATIO];
+}
+
+export function resolveObjectFit(value?: ObjectFit): string {
+  return OBJECT_FIT_MAP[value ?? DEFAULT_OBJECT_FIT];
+}
+
+export function resolveVerticalAlignment(value?: VerticalAlignment): string {
+  return ALIGNMENT_MAP[value ?? DEFAULT_VERTICAL_ALIGNMENT];
+}

package/templates/create-full/src/utils/optionPrice.ts

@@ -0,0 +1,19 @@
+import {
+  IkasProductOption,
+  IkasProductOptionSelectValue,
+  getProductOptionFormattedPrice,
+} from "@ikas/bp-storefront";
+
+export function getSelectValuePrice(
+  parentOption: IkasProductOption,
+  val: IkasProductOptionSelectValue,
+): string {
+  if (val.price == null) return "";
+
+  return getProductOptionFormattedPrice({
+    ...parentOption,
+    price: val.price,
+    priceType: val.priceType,
+    otherPrices: val.otherPrices,
+  });
+}

package/templates/create-full/src/utils/optionSet.ts

@@ -0,0 +1,17 @@
+import {
+  IkasProductOptionSet,
+  hasValidProductOptionSetValues,
+} from "@ikas/bp-storefront";
+import { showToast } from "./toast";
+
+export function validateOptionSet(
+  optionSet: IkasProductOptionSet | undefined | null,
+  errorMessage: string
+): boolean {
+  if (optionSet && !hasValidProductOptionSetValues(optionSet)) {
+    window.dispatchEvent(new CustomEvent("ikas:show-option-errors"));
+    showToast(errorMessage, "error");
+    return false;
+  }
+  return true;
+}

package/templates/create-full/src/utils/orderStatus.ts

@@ -0,0 +1,28 @@
+import { IkasOrder, IkasOrderPackageStatus } from "@ikas/bp-storefront";
+
+const STATUS_COLORS: Record<IkasOrderPackageStatus, string> = {
+  UNFULFILLED: "var(--kombos-warning)",
+  PARTIALLY_FULFILLED: "var(--kombos-warning)",
+  PARTIALLY_READY_FOR_SHIPMENT: "var(--kombos-warning)",
+  PARTIALLY_DELIVERED: "var(--kombos-warning)",
+  PARTIALLY_CANCELLED: "var(--kombos-warning)",
+  FULFILLED: "var(--kombos-success)",
+  DELIVERED: "var(--kombos-success)",
+  READY_FOR_PICK_UP: "var(--kombos-success)",
+  READY_FOR_SHIPMENT: "var(--kombos-success)",
+  CANCELLED: "var(--kombos-error)",
+  REFUNDED: "var(--kombos-error)",
+  UNABLE_TO_DELIVER: "var(--kombos-error)",
+  REFUND_REJECTED: "var(--kombos-error)",
+  CANCEL_REJECTED: "var(--kombos-error)",
+  CANCEL_REQUESTED: "var(--kombos-info)",
+  REFUND_REQUESTED: "var(--kombos-info)",
+  REFUND_REQUEST_ACCEPTED: "var(--kombos-info)",
+  PARTIALLY_REFUNDED: "var(--kombos-info)",
+};
+
+export function getStatusColor(order: IkasOrder): string | undefined {
+  const status = order.orderPackageStatus;
+  if (!status) return undefined;
+  return STATUS_COLORS[status] ?? undefined;
+}

package/templates/create-full/src/utils/pagination.ts

@@ -0,0 +1,29 @@
+export function getPageNumbers(
+  current: number,
+  total: number
+): (number | "dots")[] {
+  if (total <= 7) {
+    return Array.from({ length: total }, (_, i) => i + 1);
+  }
+
+  const pages: (number | "dots")[] = [1];
+
+  if (current > 3) {
+    pages.push("dots");
+  }
+
+  const start = Math.max(2, current - 1);
+  const end = Math.min(total - 1, current + 1);
+
+  for (let i = start; i <= end; i++) {
+    pages.push(i);
+  }
+
+  if (current < total - 2) {
+    pages.push("dots");
+  }
+
+  pages.push(total);
+
+  return pages;
+}

package/templates/create-full/src/utils/toast.ts

@@ -0,0 +1,5 @@
+export function showToast(message: string, variant: "success" | "error") {
+  window.dispatchEvent(
+    new CustomEvent("ikas:show-toast", { detail: { message, variant } })
+  );
+}

package/templates/create-full/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "DOM",
+      "DOM.Iterable",
+      "ES2022"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/templates/create-full/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vite";
+import preact from "@preact/preset-vite";
+
+export default defineConfig({
+  plugins: [preact()],
+  build: {
+    lib: {
+      entry: "./src/components/index.ts",
+      formats: ["es"]
+    },
+    rollupOptions: {
+      external: ["preact", "preact/hooks", "@ikas/component-utils"]
+    }
+  }
+});