129 lines
3.5 KiB
TypeScript
129 lines
3.5 KiB
TypeScript
import type { Package } from '../../api';
|
|
|
|
type PackageChange = {
|
|
isUpgrade: boolean;
|
|
isDowngrade: boolean;
|
|
};
|
|
|
|
export type PackageComparisonRow =
|
|
| {
|
|
id: string;
|
|
type: 'limit';
|
|
limitKey: 'max_photos' | 'max_guests' | 'gallery_days';
|
|
}
|
|
| {
|
|
id: string;
|
|
type: 'feature';
|
|
featureKey: string;
|
|
};
|
|
|
|
function collectFeatures(pkg: Package | null): Set<string> {
|
|
if (!pkg?.features) {
|
|
return new Set();
|
|
}
|
|
|
|
return new Set(Object.entries(pkg.features).filter(([, enabled]) => enabled).map(([key]) => key));
|
|
}
|
|
|
|
function compareLimit(candidate: number | null, active: number | null): number {
|
|
if (active === null) {
|
|
return candidate === null ? 0 : -1;
|
|
}
|
|
|
|
if (candidate === null) {
|
|
return 1;
|
|
}
|
|
|
|
if (candidate > active) return 1;
|
|
if (candidate < active) return -1;
|
|
return 0;
|
|
}
|
|
|
|
export function classifyPackageChange(pkg: Package, active: Package | null): PackageChange {
|
|
if (!active) {
|
|
return { isUpgrade: false, isDowngrade: false };
|
|
}
|
|
|
|
const activeFeatures = collectFeatures(active);
|
|
const candidateFeatures = collectFeatures(pkg);
|
|
|
|
const hasFeatureUpgrade = Array.from(candidateFeatures).some((feature) => !activeFeatures.has(feature));
|
|
const hasFeatureDowngrade = Array.from(activeFeatures).some((feature) => !candidateFeatures.has(feature));
|
|
|
|
const limitKeys: Array<keyof Package> = ['max_photos', 'max_guests', 'gallery_days'];
|
|
let hasLimitUpgrade = false;
|
|
let hasLimitDowngrade = false;
|
|
|
|
limitKeys.forEach((key) => {
|
|
const candidateLimit = pkg[key] ?? null;
|
|
const activeLimit = active[key] ?? null;
|
|
const delta = compareLimit(candidateLimit, activeLimit);
|
|
if (delta > 0) {
|
|
hasLimitUpgrade = true;
|
|
} else if (delta < 0) {
|
|
hasLimitDowngrade = true;
|
|
}
|
|
});
|
|
|
|
const hasUpgrade = hasFeatureUpgrade || hasLimitUpgrade;
|
|
const hasDowngrade = hasFeatureDowngrade || hasLimitDowngrade;
|
|
|
|
if (hasUpgrade) {
|
|
return { isUpgrade: true, isDowngrade: false };
|
|
}
|
|
|
|
if (hasDowngrade) {
|
|
return { isUpgrade: false, isDowngrade: true };
|
|
}
|
|
|
|
return { isUpgrade: false, isDowngrade: false };
|
|
}
|
|
|
|
export function selectRecommendedPackageId(
|
|
packages: Package[],
|
|
feature: string | null,
|
|
activePackage: Package | null
|
|
): number | null {
|
|
if (!feature) {
|
|
return null;
|
|
}
|
|
|
|
const candidates = packages.filter((pkg) => pkg.features?.[feature]);
|
|
if (candidates.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
const upgrades = candidates.filter((pkg) => classifyPackageChange(pkg, activePackage).isUpgrade);
|
|
const pool = upgrades.length ? upgrades : candidates;
|
|
const sorted = [...pool].sort((a, b) => a.price - b.price);
|
|
|
|
return sorted[0]?.id ?? null;
|
|
}
|
|
|
|
export function buildPackageComparisonRows(packages: Package[]): PackageComparisonRow[] {
|
|
const limitRows: PackageComparisonRow[] = [
|
|
{ id: 'limit.max_photos', type: 'limit', limitKey: 'max_photos' },
|
|
{ id: 'limit.max_guests', type: 'limit', limitKey: 'max_guests' },
|
|
{ id: 'limit.gallery_days', type: 'limit', limitKey: 'gallery_days' },
|
|
];
|
|
|
|
const featureKeys = new Set<string>();
|
|
packages.forEach((pkg) => {
|
|
Object.entries(pkg.features ?? {}).forEach(([key, enabled]) => {
|
|
if (enabled && key !== 'photos') {
|
|
featureKeys.add(key);
|
|
}
|
|
});
|
|
});
|
|
|
|
const featureRows = Array.from(featureKeys)
|
|
.sort((a, b) => a.localeCompare(b))
|
|
.map((featureKey) => ({
|
|
id: `feature.${featureKey}`,
|
|
type: 'feature' as const,
|
|
featureKey,
|
|
}));
|
|
|
|
return [...limitRows, ...featureRows];
|
|
}
|