@stamprally/core 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -1880,8 +1880,61 @@ var DEFAULT_SHEET_THEME = {
   fontFamily: "serif"
 };
 
+// src/domain/universalModel.ts
+function toPublicCondition(condition2) {
+  switch (condition2.type) {
+    case "qr":
+      return { type: "qr", qrEntryUrl: condition2.qrEntryUrl ?? "" };
+    case "passcode":
+      return { type: "passcode" };
+    case "gps":
+      return {
+        type: "gps",
+        latitude: condition2.latitude,
+        longitude: condition2.longitude,
+        radiusMeters: condition2.radiusMeters
+      };
+    case "custom":
+      return { type: "custom", validatorName: condition2.validatorName };
+  }
+}
+function toPublicRallyConfig(config) {
+  return {
+    ...config,
+    spots: config.spots.map((spot) => ({
+      ...spot,
+      conditions: spot.conditions.map(toPublicCondition)
+    })),
+    rewards: config.rewards.map(
+      ({ staffPasscode: _staffPasscode, digitalContentUrl: _content, ...reward }) => reward
+    )
+  };
+}
+function isPublicRallyConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const candidate = value;
+  if (candidate.secretKey !== void 0 || candidate.verificationSecrets !== void 0)
+    return false;
+  return Array.isArray(candidate.spots) && Array.isArray(candidate.rewards) && candidate.spots.every((spot) => {
+    if (typeof spot !== "object" || spot === null || Array.isArray(spot)) return false;
+    const conditions = spot.conditions;
+    return Array.isArray(conditions) && conditions.every((condition2) => {
+      if (typeof condition2 !== "object" || condition2 === null) return false;
+      const type = condition2.type;
+      return type === "qr" || type === "passcode" || type === "gps" || type === "custom";
+    });
+  }) && candidate.rewards.every((reward) => {
+    if (typeof reward !== "object" || reward === null || Array.isArray(reward)) return false;
+    const item = reward;
+    return item.staffPasscode === void 0 && item.digitalContentUrl === void 0;
+  });
+}
+
 // src/domain/publicConfig.ts
 function stripSensitiveConfig(config) {
+  if ("spots" in config && !("stamps" in config)) {
+    return toPublicRallyConfig(config);
+  }
   const rewards = config.rewards?.map(({ staffPasscode: _staffPasscode, ...reward }) => reward);
   return {
     ...config,
@@ -1988,6 +2041,180 @@ var THEME_PRESETS = [
   }
 ];
 
+// src/domain/universalValidation.ts
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function add2(errors, path, code, message) {
+  errors.push({ path, code, message });
+}
+function hasText2(value) {
+  if (typeof value === "string") return value.trim() !== "";
+  return isObject3(value) && Object.values(value).some((item) => typeof item === "string" && item.trim() !== "");
+}
+function validateCondition2(condition2, path, errors) {
+  if (!isObject3(condition2) || typeof condition2.type !== "string") {
+    add2(errors, path, "INVALID_TYPE", "Condition must have a type.");
+    return;
+  }
+  switch (condition2.type) {
+    case "qr":
+      if (typeof condition2.secretToken !== "string" || condition2.secretToken.trim() === "")
+        add2(errors, `${path}.secretToken`, "REQUIRED", "QR secretToken is required.");
+      if (condition2.qrEntryUrl !== void 0 && typeof condition2.qrEntryUrl !== "string")
+        add2(errors, `${path}.qrEntryUrl`, "INVALID_TYPE", "QR entry URL must be a string.");
+      return;
+    case "passcode":
+      if (typeof condition2.code !== "string" || condition2.code.trim() === "")
+        add2(errors, `${path}.code`, "REQUIRED", "Passcode is required.");
+      return;
+    case "gps":
+      if (typeof condition2.latitude !== "number" || !Number.isFinite(condition2.latitude) || condition2.latitude < -90 || condition2.latitude > 90 || typeof condition2.longitude !== "number" || !Number.isFinite(condition2.longitude) || condition2.longitude < -180 || condition2.longitude > 180)
+        add2(errors, path, "INVALID_COORDINATES", "GPS coordinates are invalid.");
+      if (typeof condition2.radiusMeters !== "number" || !Number.isFinite(condition2.radiusMeters) || condition2.radiusMeters <= 0)
+        add2(errors, `${path}.radiusMeters`, "INVALID_RADIUS", "GPS radius must be positive.");
+      return;
+    case "custom":
+      if (typeof condition2.validatorName !== "string" || condition2.validatorName.trim() === "")
+        add2(errors, `${path}.validatorName`, "REQUIRED", "Custom validatorName is required.");
+      return;
+    default:
+      add2(errors, `${path}.type`, "INVALID_TYPE", "Unsupported verification condition.");
+  }
+}
+function validateDag2(spots, errors) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const spot of spots) {
+    if (!isObject3(spot) || typeof spot.id !== "string") continue;
+    const prerequisites = Array.isArray(spot.prerequisites) ? spot.prerequisites.filter((item) => typeof item === "string") : [];
+    graph.set(spot.id, prerequisites);
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visiting.has(id)) {
+      add2(
+        errors,
+        `spots.${id}.prerequisites`,
+        "CYCLE_DETECTED",
+        `Dependency cycle detected at '${id}'.`
+      );
+      return;
+    }
+    if (visited.has(id)) return;
+    visiting.add(id);
+    for (const prerequisite of graph.get(id) ?? [])
+      if (graph.has(prerequisite)) visit(prerequisite);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const id of graph.keys()) visit(id);
+}
+function validateAdminRallyConfig(value) {
+  const errors = [];
+  if (!isObject3(value))
+    return {
+      valid: false,
+      errors: [{ path: "", code: "INVALID_TYPE", message: "Admin config must be an object." }]
+    };
+  if (typeof value.id !== "string" || value.id.trim() === "")
+    add2(errors, "id", "REQUIRED", "Rally ID is required.");
+  if (typeof value.version !== "string" || value.version.trim() === "")
+    add2(errors, "version", "INVALID_VERSION", "Version is required.");
+  if (!Array.isArray(value.spots)) {
+    add2(errors, "spots", "INVALID_TYPE", "spots must be an array.");
+  } else {
+    const ids = [];
+    value.spots.forEach((spot, index) => {
+      const path = `spots[${index}]`;
+      if (!isObject3(spot)) {
+        add2(errors, path, "INVALID_TYPE", "Spot must be an object.");
+        return;
+      }
+      if (typeof spot.id !== "string" || spot.id.trim() === "")
+        add2(errors, `${path}.id`, "REQUIRED", "Spot ID is required.");
+      else if (ids.includes(spot.id))
+        add2(errors, `${path}.id`, "DUPLICATE_ID", `Duplicate spot ID '${spot.id}'.`);
+      else ids.push(spot.id);
+      if (!hasText2(spot.name)) add2(errors, `${path}.name`, "REQUIRED", "Spot name is required.");
+      if (typeof spot.orderIndex !== "number" || !Number.isInteger(spot.orderIndex))
+        add2(errors, `${path}.orderIndex`, "INVALID_TYPE", "orderIndex must be an integer.");
+      if (!Array.isArray(spot.conditions) || spot.conditions.length === 0)
+        add2(errors, `${path}.conditions`, "REQUIRED", "At least one condition is required.");
+      else {
+        spot.conditions.forEach((condition2, conditionIndex) => {
+          validateCondition2(condition2, `${path}.conditions[${conditionIndex}]`, errors);
+        });
+      }
+    });
+    validateDag2(value.spots, errors);
+  }
+  if (!Array.isArray(value.rewards))
+    add2(errors, "rewards", "INVALID_TYPE", "rewards must be an array.");
+  else {
+    const ids = [];
+    value.rewards.forEach((reward, index) => {
+      const path = `rewards[${index}]`;
+      if (!isObject3(reward)) {
+        add2(errors, path, "INVALID_TYPE", "Reward must be an object.");
+        return;
+      }
+      if (typeof reward.id !== "string" || reward.id.trim() === "")
+        add2(errors, `${path}.id`, "REQUIRED", "Reward ID is required.");
+      else if (ids.includes(reward.id))
+        add2(errors, `${path}.id`, "DUPLICATE_ID", `Duplicate reward ID '${reward.id}'.`);
+      else ids.push(reward.id);
+      if (!hasText2(reward.title))
+        add2(errors, `${path}.title`, "REQUIRED", "Reward title is required.");
+      if (typeof reward.requiredStampCount !== "number" || !Number.isInteger(reward.requiredStampCount) || reward.requiredStampCount < 0)
+        add2(
+          errors,
+          `${path}.requiredStampCount`,
+          "INVALID_REWARD",
+          "requiredStampCount must be a non-negative integer."
+        );
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validatePublicRallyConfig(value) {
+  const errors = [];
+  if (!isObject3(value))
+    return {
+      valid: false,
+      errors: [{ path: "", code: "INVALID_TYPE", message: "Public config must be an object." }]
+    };
+  if ("secretKey" in value || "verificationSecrets" in value)
+    add2(
+      errors,
+      "",
+      "SECRET_IN_PUBLIC_CONFIG",
+      "Public config must not contain server verification secrets."
+    );
+  if (!Array.isArray(value.spots)) add2(errors, "spots", "INVALID_TYPE", "spots must be an array.");
+  else
+    value.spots.forEach((spot, index) => {
+      if (!isObject3(spot) || !Array.isArray(spot.conditions)) return;
+      spot.conditions.forEach((condition2, conditionIndex) => {
+        if (!isObject3(condition2)) return;
+        if ("secretToken" in condition2 || "code" in condition2 || "secretParams" in condition2)
+          add2(
+            errors,
+            `spots[${index}].conditions[${conditionIndex}]`,
+            "SECRET_IN_PUBLIC_CONFIG",
+            "Public condition contains verification secret material."
+          );
+      });
+    });
+  return { valid: errors.length === 0, errors };
+}
+function isAdminRallyConfig(value) {
+  return validateAdminRallyConfig(value).valid;
+}
+function isPublicRallyConfigShape(value) {
+  return validatePublicRallyConfig(value).valid;
+}
+
 // src/security/snapshotToken.ts
 var encoder2 = new TextEncoder();
 function cryptoApi2() {
@@ -2128,8 +2355,11 @@ exports.evaluateConditionDetailed = evaluateConditionDetailed;
 exports.exportProgressToken = exportProgressToken;
 exports.getCurrentGeoContext = getCurrentGeoContext;
 exports.importProgressToken = importProgressToken;
+exports.isAdminRallyConfig = isAdminRallyConfig;
 exports.isGeolocationSupported = isGeolocationSupported;
 exports.isNfcSupported = isNfcSupported;
+exports.isPublicRallyConfig = isPublicRallyConfig;
+exports.isPublicRallyConfigShape = isPublicRallyConfigShape;
 exports.isQrSupported = isQrSupported;
 exports.isRewardState = isRewardState;
 exports.isStampRallyState = isStampRallyState;
@@ -2143,6 +2373,9 @@ exports.reconcileRewardStates = reconcileRewardStates;
 exports.resolveLocalizedText = resolveLocalizedText;
 exports.stripSensitiveConfig = stripSensitiveConfig;
 exports.toLocalizedString = toLocalizedString;
+exports.toPublicRallyConfig = toPublicRallyConfig;
+exports.validateAdminRallyConfig = validateAdminRallyConfig;
+exports.validatePublicRallyConfig = validatePublicRallyConfig;
 exports.validateRallyConfig = validateRallyConfig;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;