@voyantjs/pricing 0.26.8 → 0.26.9

package/dist/service-public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AASjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AAwE/B,eAAO,MAAM,oBAAoB;kCAEzB,kBAAkB,aACX,MAAM,SACV,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0R5B,kBAAkB,aACX,MAAM,SACV,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGzC,CAAA"}
+{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAWjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AA+J/B,eAAO,MAAM,oBAAoB;kCAEzB,kBAAkB,aACX,MAAM,SACV,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA+R5B,kBAAkB,aACX,MAAM,SACV,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGzC,CAAA"}

package/dist/service-public.js

@@ -1,7 +1,8 @@
 import { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
 import { optionUnits, productOptions, products } from "@voyantjs/products/schema";
 import { and, asc, desc, eq, gte, inArray, lte, ne, or, sql } from "drizzle-orm";
-import { optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, priceCatalogs, } from "./schema.js";
+import { optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, priceCatalogs, priceSchedules, } from "./schema.js";
+import { pickRulesForDate } from "./service-rule-resolver.js";
 function normalizeDate(value) {
     if (!value) {
         return null;
@@ -48,6 +49,68 @@ async function resolvePublicCatalog(db, input) {
         .limit(1);
     return catalog ?? null;
 }
+async function resolveQueryDate(db, query) {
+    if (query.date)
+        return query.date;
+    if (!query.departureId)
+        return null;
+    const [slot] = await db
+        .select({ dateLocal: availabilitySlots.dateLocal })
+        .from(availabilitySlots)
+        .where(eq(availabilitySlots.id, query.departureId))
+        .limit(1);
+    return slot?.dateLocal ?? null;
+}
+async function narrowRulesByDate(db, rules, isoDate) {
+    if (rules.length === 0)
+        return rules;
+    const scheduleIds = Array.from(new Set(rules.map((r) => r.priceScheduleId).filter((id) => id !== null)));
+    const schedules = scheduleIds.length > 0
+        ? await db
+            .select({
+            id: priceSchedules.id,
+            active: priceSchedules.active,
+            priority: priceSchedules.priority,
+            recurrenceRule: priceSchedules.recurrenceRule,
+            validFrom: priceSchedules.validFrom,
+            validTo: priceSchedules.validTo,
+            weekdays: priceSchedules.weekdays,
+            timezone: priceSchedules.timezone,
+        })
+            .from(priceSchedules)
+            .where(inArray(priceSchedules.id, scheduleIds))
+        : [];
+    const scheduleMap = new Map(schedules.map((s) => [
+        s.id,
+        {
+            id: s.id,
+            active: s.active,
+            priority: s.priority,
+            recurrenceRule: s.recurrenceRule,
+            validFrom: s.validFrom,
+            validTo: s.validTo,
+            weekdays: s.weekdays ?? null,
+            timezone: s.timezone,
+        },
+    ]));
+    const rulesByOption = new Map();
+    for (const r of rules) {
+        const existing = rulesByOption.get(r.optionId) ?? [];
+        existing.push(r);
+        rulesByOption.set(r.optionId, existing);
+    }
+    const winners = [];
+    for (const [, candidateRules] of rulesByOption) {
+        const picked = pickRulesForDate(candidateRules, scheduleMap, isoDate);
+        const winnerId = picked[0]?.id;
+        if (!winnerId)
+            continue;
+        const winner = candidateRules.find((r) => r.id === winnerId);
+        if (winner)
+            winners.push(winner);
+    }
+    return winners;
+}
 export const publicPricingService = {
     async getProductPricingSnapshot(db, productId, query) {
         const product = await ensurePublicProduct(db, productId);
@@ -87,7 +150,8 @@ export const publicPricingService = {
             };
         }
         const optionIds = options.map((option) => option.id);
-        const [units, rules] = await Promise.all([
+        const resolvedDate = await resolveQueryDate(db, query);
+        const [units, allRules] = await Promise.all([
             db
                 .select({
                 id: optionUnits.id,
@@ -112,11 +176,13 @@ export const publicPricingService = {
                 maxPerBooking: optionPriceRules.maxPerBooking,
                 isDefault: optionPriceRules.isDefault,
                 cancellationPolicyId: optionPriceRules.cancellationPolicyId,
+                priceScheduleId: optionPriceRules.priceScheduleId,
             })
                 .from(optionPriceRules)
                 .where(and(eq(optionPriceRules.productId, productId), inArray(optionPriceRules.optionId, optionIds), eq(optionPriceRules.priceCatalogId, catalog.id), eq(optionPriceRules.active, true)))
                 .orderBy(desc(optionPriceRules.isDefault), asc(optionPriceRules.name)),
         ]);
+        const rules = resolvedDate ? await narrowRulesByDate(db, allRules, resolvedDate) : allRules;
         const ruleIds = rules.map((rule) => rule.id);
         const [unitPrices, startTimeAdjustments] = await Promise.all([
             ruleIds.length > 0

package/dist/service-rule-resolver.d.ts

@@ -0,0 +1,44 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export interface ResolverRuleInput {
+    id: string;
+    name: string;
+    isDefault: boolean;
+    priceScheduleId: string | null;
+}
+export interface ResolverScheduleInput {
+    id: string;
+    active: boolean;
+    priority: number;
+    recurrenceRule: string;
+    validFrom: string | null;
+    validTo: string | null;
+    weekdays: string[] | null;
+    timezone: string | null;
+}
+/**
+ * Pick the option price rule that applies to a given date, given a set of
+ * candidate rules and their schedules.
+ *
+ * - Rules with a matching schedule beat rules without one.
+ * - Among scheduled matches, highest `priority` wins. Ties: `isDefault` first,
+ *   then alphabetic by `name`.
+ * - When no schedule matches, a rule with `isDefault=true` and no schedule acts
+ *   as the fallback. Without one, returns an empty array.
+ */
+export declare function pickRulesForDate(rules: ResolverRuleInput[], schedules: Map<string, ResolverScheduleInput>, isoDate: string): ResolverRuleInput[];
+export interface ResolveOptionPriceRulesParams {
+    productId: string;
+    optionIds: string[];
+    catalogId: string;
+    date: string;
+}
+/**
+ * DB-backed wrapper around `pickRulesForDate`. Fetches active rules for the
+ * product/option/catalog plus their schedules, then picks the winning rule
+ * per option for the given date.
+ *
+ * Returns a Map keyed by optionId. Options whose rules don't match the date
+ * (and have no default) are absent from the map.
+ */
+export declare function resolveOptionPriceRulesForDate(db: PostgresJsDatabase, params: ResolveOptionPriceRulesParams): Promise<Map<string, ResolverRuleInput>>;
+//# sourceMappingURL=service-rule-resolver.d.ts.map

package/dist/service-rule-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-rule-resolver.d.ts","sourceRoot":"","sources":["../src/service-rule-resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAMjE,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAoED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,iBAAiB,EAAE,EAC1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,EAC7C,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAgCrB;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;GAOG;AACH,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CA8EzC"}

package/dist/service-rule-resolver.js

@@ -0,0 +1,172 @@
+import { and, eq, inArray } from "drizzle-orm";
+import { rrulestr } from "rrule";
+import { priceSchedules } from "./schema-catalogs.js";
+import { optionPriceRules } from "./schema-option-rules.js";
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const WEEKDAY_CODES = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+function weekdayCode(isoDate) {
+    const d = new Date(`${isoDate}T00:00:00Z`);
+    return WEEKDAY_CODES[d.getUTCDay()] ?? "MO";
+}
+function dateInWindow(isoDate, from, to) {
+    if (from && isoDate < from)
+        return false;
+    if (to && isoDate > to)
+        return false;
+    return true;
+}
+function rruleMatchesDate(ruleString, isoDate, anchor) {
+    const trimmed = ruleString.trim();
+    if (trimmed === "")
+        return true;
+    const dtstart = `${anchor.replace(/-/g, "")}T000000Z`;
+    const hasDtstart = /(?:^|\n)DTSTART[:;]/.test(trimmed);
+    const hasRrule = /(?:^|\n)RRULE[:;]/.test(trimmed);
+    const body = hasRrule ? trimmed : `RRULE:${trimmed}`;
+    const fullRule = hasDtstart ? body : `DTSTART:${dtstart}\n${body}`;
+    let parsed;
+    try {
+        parsed = rrulestr(fullRule);
+    }
+    catch {
+        return false;
+    }
+    const start = new Date(`${isoDate}T00:00:00Z`);
+    const end = new Date(start.getTime() + 24 * 60 * 60 * 1000);
+    const occurrences = parsed.between(start, end, true);
+    return occurrences.some((occ) => occ.toISOString().slice(0, 10) === isoDate);
+}
+function scheduleMatchesDate(s, isoDate) {
+    if (!s.active)
+        return false;
+    if (!dateInWindow(isoDate, s.validFrom, s.validTo))
+        return false;
+    if (s.weekdays && s.weekdays.length > 0) {
+        if (!s.weekdays.includes(weekdayCode(isoDate)))
+            return false;
+    }
+    const anchor = s.validFrom ?? "2000-01-01";
+    if (!rruleMatchesDate(s.recurrenceRule, isoDate, anchor))
+        return false;
+    return true;
+}
+function compareMatches(a, b) {
+    if (b.priority !== a.priority)
+        return b.priority - a.priority;
+    const aDef = a.rule.isDefault ? 1 : 0;
+    const bDef = b.rule.isDefault ? 1 : 0;
+    if (aDef !== bDef)
+        return bDef - aDef;
+    return a.rule.name.localeCompare(b.rule.name);
+}
+/**
+ * Pick the option price rule that applies to a given date, given a set of
+ * candidate rules and their schedules.
+ *
+ * - Rules with a matching schedule beat rules without one.
+ * - Among scheduled matches, highest `priority` wins. Ties: `isDefault` first,
+ *   then alphabetic by `name`.
+ * - When no schedule matches, a rule with `isDefault=true` and no schedule acts
+ *   as the fallback. Without one, returns an empty array.
+ */
+export function pickRulesForDate(rules, schedules, isoDate) {
+    if (!ISO_DATE_RE.test(isoDate)) {
+        throw new Error(`pickRulesForDate: expected ISO yyyy-mm-dd, got "${isoDate}"`);
+    }
+    const matches = [];
+    for (const rule of rules) {
+        if (rule.priceScheduleId === null) {
+            if (rule.isDefault) {
+                matches.push({ rule, priority: Number.NEGATIVE_INFINITY, scheduled: false });
+            }
+            continue;
+        }
+        const schedule = schedules.get(rule.priceScheduleId);
+        if (!schedule)
+            continue;
+        if (!scheduleMatchesDate(schedule, isoDate))
+            continue;
+        matches.push({ rule, priority: schedule.priority, scheduled: true });
+    }
+    if (matches.length === 0)
+        return [];
+    const scheduled = matches.filter((m) => m.scheduled);
+    if (scheduled.length > 0) {
+        scheduled.sort(compareMatches);
+        const winner = scheduled[0];
+        return winner ? [winner.rule] : [];
+    }
+    matches.sort(compareMatches);
+    const winner = matches[0];
+    return winner ? [winner.rule] : [];
+}
+/**
+ * DB-backed wrapper around `pickRulesForDate`. Fetches active rules for the
+ * product/option/catalog plus their schedules, then picks the winning rule
+ * per option for the given date.
+ *
+ * Returns a Map keyed by optionId. Options whose rules don't match the date
+ * (and have no default) are absent from the map.
+ */
+export async function resolveOptionPriceRulesForDate(db, params) {
+    if (params.optionIds.length === 0)
+        return new Map();
+    const rules = await db
+        .select({
+        id: optionPriceRules.id,
+        optionId: optionPriceRules.optionId,
+        name: optionPriceRules.name,
+        isDefault: optionPriceRules.isDefault,
+        priceScheduleId: optionPriceRules.priceScheduleId,
+    })
+        .from(optionPriceRules)
+        .where(and(eq(optionPriceRules.productId, params.productId), inArray(optionPriceRules.optionId, params.optionIds), eq(optionPriceRules.priceCatalogId, params.catalogId), eq(optionPriceRules.active, true)));
+    const scheduleIds = Array.from(new Set(rules.map((r) => r.priceScheduleId).filter((id) => id !== null)));
+    const schedules = scheduleIds.length > 0
+        ? await db
+            .select({
+            id: priceSchedules.id,
+            active: priceSchedules.active,
+            priority: priceSchedules.priority,
+            recurrenceRule: priceSchedules.recurrenceRule,
+            validFrom: priceSchedules.validFrom,
+            validTo: priceSchedules.validTo,
+            weekdays: priceSchedules.weekdays,
+            timezone: priceSchedules.timezone,
+        })
+            .from(priceSchedules)
+            .where(inArray(priceSchedules.id, scheduleIds))
+        : [];
+    const scheduleMap = new Map(schedules.map((s) => [
+        s.id,
+        {
+            id: s.id,
+            active: s.active,
+            priority: s.priority,
+            recurrenceRule: s.recurrenceRule,
+            validFrom: s.validFrom,
+            validTo: s.validTo,
+            weekdays: s.weekdays ?? null,
+            timezone: s.timezone,
+        },
+    ]));
+    const rulesByOption = new Map();
+    for (const r of rules) {
+        const existing = rulesByOption.get(r.optionId) ?? [];
+        existing.push({
+            id: r.id,
+            name: r.name,
+            isDefault: r.isDefault,
+            priceScheduleId: r.priceScheduleId,
+        });
+        rulesByOption.set(r.optionId, existing);
+    }
+    const result = new Map();
+    for (const [optionId, candidateRules] of rulesByOption) {
+        const picked = pickRulesForDate(candidateRules, scheduleMap, params.date);
+        const first = picked[0];
+        if (first)
+            result.set(optionId, first);
+    }
+    return result;
+}

package/dist/validation-public.d.ts

@@ -2,6 +2,8 @@ import { z } from "zod";
 export declare const publicProductPricingQuerySchema: z.ZodObject<{
     catalogId: z.ZodOptional<z.ZodString>;
     optionId: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+    departureId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const publicAvailabilitySnapshotQuerySchema: z.ZodObject<{
     optionId: z.ZodOptional<z.ZodString>;

package/dist/validation-public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-public.d.ts","sourceRoot":"","sources":["../src/validation-public.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;iBAOhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYtC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAS1C,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;iBAcvC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM3C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA"}
+{"version":3,"file":"validation-public.d.ts","sourceRoot":"","sources":["../src/validation-public.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;iBAOhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYtC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAS1C,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;iBAcvC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM3C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA"}

package/dist/validation-public.js

@@ -6,6 +6,8 @@ const isoDateSchema = z.string().date();
 export const publicProductPricingQuerySchema = z.object({
     catalogId: z.string().optional(),
     optionId: z.string().optional(),
+    date: isoDateSchema.optional(),
+    departureId: z.string().optional(),
 });
 export const publicAvailabilitySnapshotQuerySchema = z.object({
     optionId: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/pricing",
-  "version": "0.26.8",
+  "version": "0.26.9",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -38,17 +38,18 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
+    "rrule": "^2.8.1",
     "zod": "^4.3.6",
-    "@voyantjs/availability": "0.26.8",
-    "@voyantjs/core": "0.26.8",
-    "@voyantjs/db": "0.26.8",
-    "@voyantjs/hono": "0.26.8",
-    "@voyantjs/products": "0.26.8"
+    "@voyantjs/availability": "0.26.9",
+    "@voyantjs/core": "0.26.9",
+    "@voyantjs/db": "0.26.9",
+    "@voyantjs/hono": "0.26.9",
+    "@voyantjs/products": "0.26.9"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
-    "@voyantjs/extras": "0.26.8",
-    "@voyantjs/facilities": "0.26.8",
+    "@voyantjs/extras": "0.26.9",
+    "@voyantjs/facilities": "0.26.9",
     "@voyantjs/voyant-typescript-config": "0.1.0"
   },
   "files": [