@jjlmoya/utils-games-development 1.50.0 → 1.52.0

package/src/tool/saveFileEditor/logic.ts

@@ -0,0 +1,139 @@
+export type EncryptionMethod = 'base64' | 'xor' | 'raw';
+
+export interface ObfuscationOptions {
+  method: EncryptionMethod;
+  xorKey: string;
+}
+
+export interface ParseResult {
+  success: boolean;
+  data: unknown | null;
+  error?: string;
+  detectedMethod?: EncryptionMethod;
+}
+
+export function strToUtf8Bytes(str: string): Uint8Array {
+  return new TextEncoder().encode(str);
+}
+
+export function utf8BytesToStr(bytes: Uint8Array): string {
+  return new TextDecoder().decode(bytes);
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+export function base64ToBytes(base64Str: string): Uint8Array {
+  const cleanStr = base64Str.trim().replace(/\s+/g, '');
+  const binary = atob(cleanStr);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+export function applyXor(data: Uint8Array, keyStr: string): Uint8Array {
+  if (!keyStr) return data;
+  const keyBytes = strToUtf8Bytes(keyStr);
+  if (keyBytes.length === 0) return data;
+
+  const result = new Uint8Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    result[i] = data[i]! ^ keyBytes[i % keyBytes.length]!;
+  }
+  return result;
+}
+
+function getDecodedString(trimmed: string, options: ObfuscationOptions): string {
+  if (options.method === 'raw') return trimmed;
+  const bytes = base64ToBytes(trimmed);
+  if (options.method === 'base64') return utf8BytesToStr(bytes);
+  if (options.method === 'xor') {
+    return utf8BytesToStr(applyXor(bytes, options.xorKey));
+  }
+  return trimmed;
+}
+
+export function decodeSaveData(rawContent: string, options: ObfuscationOptions): ParseResult {
+  const trimmed = rawContent.trim();
+  if (!trimmed) {
+    return { success: false, data: null, error: 'Empty file' };
+  }
+
+  try {
+    const decodedText = getDecodedString(trimmed, options);
+    return {
+      success: true,
+      data: JSON.parse(decodedText),
+      detectedMethod: options.method,
+    };
+  } catch (err: unknown) {
+    return {
+      success: false,
+      data: null,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export function encodeSaveData(data: unknown, options: ObfuscationOptions): string {
+  const jsonStr = JSON.stringify(data, null, 2);
+  
+  if (options.method === 'raw') {
+    return jsonStr;
+  }
+
+  const utf8Bytes = strToUtf8Bytes(jsonStr);
+
+  if (options.method === 'base64') {
+    return bytesToBase64(utf8Bytes);
+  }
+
+  if (options.method === 'xor') {
+    const xorBytes = applyXor(utf8Bytes, options.xorKey);
+    return bytesToBase64(xorBytes);
+  }
+
+  return jsonStr;
+}
+
+export function detectFormat(content: string, xorKey: string = ''): EncryptionMethod {
+  const trimmed = content.trim();
+  if (!trimmed) return 'raw';
+
+  try {
+    JSON.parse(trimmed);
+    return 'raw';
+  } catch {
+    void 0;
+  }
+
+  if (xorKey) {
+    try {
+      const bytes = base64ToBytes(trimmed);
+      const text = utf8BytesToStr(applyXor(bytes, xorKey));
+      JSON.parse(text);
+      return 'xor';
+    } catch {
+      void 0;
+    }
+  }
+
+  try {
+    const bytes = base64ToBytes(trimmed);
+    const text = utf8BytesToStr(bytes);
+    JSON.parse(text);
+    return 'base64';
+  } catch {
+    void 0;
+  }
+
+  return 'raw';
+}

package/src/tool/saveFileEditor/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { saveFileEditor } from './entry';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const loader = saveFileEditor.i18n[locale] ?? saveFileEditor.i18n.en;
+const content = loader ? await loader() : null;
+---
+
+{content && content.seo && content.seo.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/saveFileEditor/ui.ts

@@ -0,0 +1,24 @@
+export interface SaveFileEditorUI extends Record<string, string> {
+  title: string;
+  subtitle: string;
+  dropSaveFile: string;
+  orSelectFile: string;
+  encryptionMethod: string;
+  methodBase64: string;
+  methodXor: string;
+  methodRaw: string;
+  xorKeyLabel: string;
+  xorKeyPlaceholder: string;
+  jsonRawTitle: string;
+  encodeAndDownload: string;
+  copyEncoded: string;
+  copiedNotice: string;
+  decodedKeysCount: string;
+  dataSize: string;
+  detectedFormat: string;
+  exportPreviewLabel: string;
+  decodePanelTitle: string;
+  exportPanelTitle: string;
+  decodeError: string;
+  bytesUnit: string;
+}

package/src/tools.ts

@@ -3,9 +3,14 @@ import type { ToolDefinition } from './types';
 import { STEAM_CAPSULE_GENERATOR_TOOL } from './tool/steamCapsuleGenerator';
 import { ITCHIO_GAME_TESTER_TOOL } from './tool/itchioGameTester';
 import { SPRITE_SHEET_PACKER_TOOL } from './tool/spriteSheetPacker';
+import { AUDIO_LOOP_POINT_FINDER_TOOL } from './tool/audioLoopPointFinder';
+import { SAVE_FILE_EDITOR_TOOL } from './tool/saveFileEditor';
 
 export const ALL_TOOLS: ToolDefinition[] = [
   STEAM_CAPSULE_GENERATOR_TOOL,
   ITCHIO_GAME_TESTER_TOOL,
   SPRITE_SHEET_PACKER_TOOL,
+  AUDIO_LOOP_POINT_FINDER_TOOL,
+  SAVE_FILE_EDITOR_TOOL,
 ];
+