@playcademy/sdk 0.2.2 → 0.2.3

package/dist/index.js

@@ -241,6 +241,7 @@ var detectOutputFormat = () => {
 };
 var colors = {
   reset: "\x1B[0m",
+  bold: "\x1B[1m",
   dim: "\x1B[2m",
   red: "\x1B[31m",
   yellow: "\x1B[33m",
@@ -262,44 +263,48 @@ var getLevelColor = (level) => {
       return colors.reset;
   }
 };
-var formatBrowserOutput = (level, message, context) => {
+var formatBrowserOutput = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const levelUpper = level.toUpperCase();
   const consoleMethod = getConsoleMethod(level);
+  const scopePrefix = scope ? `[${scope}] ` : "";
   if (context && Object.keys(context).length > 0) {
-    consoleMethod(`[${timestamp}] ${levelUpper}`, message, context);
+    consoleMethod(`[${timestamp}] ${levelUpper}`, `${scopePrefix}${message}`, context);
   } else {
-    consoleMethod(`[${timestamp}] ${levelUpper}`, message);
+    consoleMethod(`[${timestamp}] ${levelUpper}`, `${scopePrefix}${message}`);
   }
 };
-var formatColorTTY = (level, message, context) => {
+var formatColorTTY = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const levelColor = getLevelColor(level);
   const levelUpper = level.toUpperCase().padEnd(5);
   const consoleMethod = getConsoleMethod(level);
   const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+  const scopePrefix = scope ? `${colors.bold}[${scope}]${colors.reset} ` : "";
   if (context && Object.keys(context).length > 0) {
-    consoleMethod(`${coloredPrefix} ${message}`, context);
+    consoleMethod(`${coloredPrefix} ${scopePrefix}${message}`, context);
   } else {
-    consoleMethod(`${coloredPrefix} ${message}`);
+    consoleMethod(`${coloredPrefix} ${scopePrefix}${message}`);
   }
 };
-var formatJSONSingleLine = (level, message, context) => {
+var formatJSONSingleLine = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
     level: level.toUpperCase(),
+    ...scope && { scope },
     message,
     ...context && Object.keys(context).length > 0 && { context }
   };
   const consoleMethod = getConsoleMethod(level);
   consoleMethod(JSON.stringify(logEntry));
 };
-var formatJSONPretty = (level, message, context) => {
+var formatJSONPretty = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
     level: level.toUpperCase(),
+    ...scope && { scope },
     message,
     ...context && Object.keys(context).length > 0 && { context }
   };
@@ -340,36 +345,37 @@ var shouldLog = (level) => {
   return levelPriority[level] >= levelPriority[minLevel];
 };
 var customHandler;
-var performLog = (level, message, context) => {
+var performLog = (level, message, context, scope) => {
   if (!shouldLog(level))
     return;
   if (customHandler) {
-    customHandler(level, message, context);
+    customHandler(level, message, context, scope);
     return;
   }
   const outputFormat = detectOutputFormat();
   switch (outputFormat) {
     case "browser":
-      formatBrowserOutput(level, message, context);
+      formatBrowserOutput(level, message, context, scope);
       break;
     case "color-tty":
-      formatColorTTY(level, message, context);
+      formatColorTTY(level, message, context, scope);
       break;
     case "json-single-line":
-      formatJSONSingleLine(level, message, context);
+      formatJSONSingleLine(level, message, context, scope);
       break;
     case "json-pretty":
-      formatJSONPretty(level, message, context);
+      formatJSONPretty(level, message, context, scope);
       break;
   }
 };
-var createLogger = () => {
+var createLogger = (scopeName) => {
   return {
-    debug: (message, context) => performLog("debug", message, context),
-    info: (message, context) => performLog("info", message, context),
-    warn: (message, context) => performLog("warn", message, context),
-    error: (message, context) => performLog("error", message, context),
-    log: performLog
+    debug: (message, context) => performLog("debug", message, context, scopeName),
+    info: (message, context) => performLog("info", message, context, scopeName),
+    warn: (message, context) => performLog("warn", message, context, scopeName),
+    error: (message, context) => performLog("error", message, context, scopeName),
+    log: (level, message, context) => performLog(level, message, context, scopeName),
+    scope: (name) => createLogger(scopeName ? `${scopeName}.${name}` : name)
   };
 };
 var log = createLogger();
@@ -384,26 +390,87 @@ class PlaycademyError extends Error {
 
 class ApiError extends Error {
   status;
+  code;
   details;
-  constructor(status, message, details) {
-    super(`${status} ${message}`);
+  rawBody;
+  constructor(status, code, message, details, rawBody) {
+    super(message);
     this.status = status;
+    this.name = "ApiError";
+    this.code = code;
     this.details = details;
+    this.rawBody = rawBody;
     Object.setPrototypeOf(this, ApiError.prototype);
   }
+  static fromResponse(status, statusText, body) {
+    if (body && typeof body === "object" && "error" in body) {
+      const errorBody = body;
+      const err = errorBody.error;
+      if (err && typeof err === "object") {
+        return new ApiError(status, err.code ?? statusCodeToErrorCode(status), err.message ?? statusText, err.details, body);
+      }
+    }
+    return new ApiError(status, statusCodeToErrorCode(status), statusText, undefined, body);
+  }
+  is(code) {
+    return this.code === code;
+  }
+  isClientError() {
+    return this.status >= 400 && this.status < 500;
+  }
+  isServerError() {
+    return this.status >= 500;
+  }
+  isRetryable() {
+    return this.isServerError() || this.code === "TOO_MANY_REQUESTS" || this.code === "RATE_LIMITED" || this.code === "TIMEOUT";
+  }
+}
+function statusCodeToErrorCode(status) {
+  switch (status) {
+    case 400:
+      return "BAD_REQUEST";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 405:
+      return "METHOD_NOT_ALLOWED";
+    case 409:
+      return "CONFLICT";
+    case 410:
+      return "GONE";
+    case 412:
+      return "PRECONDITION_FAILED";
+    case 413:
+      return "PAYLOAD_TOO_LARGE";
+    case 422:
+      return "VALIDATION_FAILED";
+    case 429:
+      return "TOO_MANY_REQUESTS";
+    case 500:
+      return "INTERNAL_ERROR";
+    case 501:
+      return "NOT_IMPLEMENTED";
+    case 503:
+      return "SERVICE_UNAVAILABLE";
+    case 504:
+      return "TIMEOUT";
+    default:
+      return status >= 500 ? "INTERNAL_ERROR" : "BAD_REQUEST";
+  }
 }
 function extractApiErrorInfo(error) {
   if (!(error instanceof ApiError)) {
     return null;
   }
-  const info = {
+  return {
     status: error.status,
-    statusText: error.message
+    code: error.code,
+    message: error.message,
+    ...error.details !== undefined && { details: error.details }
   };
-  if (error.details) {
-    info.details = error.details;
-  }
-  return info;
 }
 
 // src/core/static/login.ts
@@ -1030,6 +1097,96 @@ function createUsersNamespace(client) {
     }
   };
 }
+// ../constants/src/achievements.ts
+var ACHIEVEMENT_IDS = {
+  PLAY_ANY_GAME_DAILY: "play_any_game_daily",
+  DAILY_CHEST_OPEN: "daily_chest_open",
+  LEADERBOARD_TOP3_DAILY: "leaderboard_top3_daily",
+  LEADERBOARD_TOP3_WEEKLY: "leaderboard_top3_weekly",
+  FIRST_SCORE_ANY_GAME: "first_score_any_game",
+  PERSONAL_BEST_ANY_GAME: "personal_best_any_game"
+};
+var ACHIEVEMENT_DEFINITIONS = [
+  {
+    id: ACHIEVEMENT_IDS.PLAY_ANY_GAME_DAILY,
+    title: "Play any game",
+    description: "Play any arcade game for at least 60 seconds in a single session.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "time_played_session",
+    completionConfig: { minSeconds: 60 },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.DAILY_CHEST_OPEN,
+    title: "Opened the daily chest",
+    description: "Find the chest on the map and open it to claim your reward.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "interaction",
+    completionConfig: { triggerId: "bunny_chest" },
+    target: { map: "arcade" },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_DAILY,
+    title: "Daily Champion",
+    description: "Finish in the top 3 of any game leaderboard for the day.",
+    scope: "daily",
+    rewardCredits: 25,
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [50, 30, 15]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_WEEKLY,
+    title: "Weekly Legend",
+    description: "Finish in the top 3 of any game leaderboard for the week.",
+    scope: "weekly",
+    rewardCredits: 50,
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [100, 60, 30]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.FIRST_SCORE_ANY_GAME,
+    title: "First Score",
+    description: "Submit your first score in any arcade game.",
+    scope: "game",
+    rewardCredits: 5,
+    limit: 1,
+    completionType: "first_score",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.PERSONAL_BEST_ANY_GAME,
+    title: "Personal Best",
+    description: "Beat your personal best score in any arcade game.",
+    scope: "daily",
+    rewardCredits: 5,
+    limit: 3,
+    completionType: "personal_best",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  }
+];
+// ../constants/src/typescript.ts
+var TSC_PACKAGE = "@typescript/native-preview";
+var USE_NATIVE_TSC = TSC_PACKAGE.includes("native-preview");
 // ../constants/src/overworld.ts
 var ITEM_SLUGS = {
   PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
@@ -1702,7 +1859,7 @@ async function request({
     const errorBody = await clonedRes.json().catch(() => clonedRes.text().catch(() => {
       return;
     })) ?? undefined;
-    throw new ApiError(res.status, res.statusText, errorBody);
+    throw ApiError.fromResponse(res.status, res.statusText, errorBody);
   }
   if (res.status === 204)
     return;