zikade 0.1.0

package/README.md

@@ -0,0 +1 @@
+# Zikade

package/dist/ZikadeProvider.d.ts

@@ -0,0 +1,16 @@
+import React, { ReactNode } from "react";
+import { createZikade } from "./createZikade";
+import type { LocaleTranslations } from "./types";
+type ZikadeContextType<T extends LocaleTranslations> = {
+    zikade: ReturnType<typeof createZikade<T>>;
+    currentLocale: keyof T;
+    setLanguage: (locale: keyof T) => void;
+};
+declare const ZikadeContext: React.Context<ZikadeContextType<any> | undefined>;
+type ZikadeProviderProps<T extends LocaleTranslations> = {
+    translations: T;
+    defaultLocale: keyof T;
+    children: ReactNode;
+};
+export declare function ZikadeProvider<T extends LocaleTranslations>({ translations, defaultLocale, children }: ZikadeProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+export { ZikadeContext };

package/dist/ZikadeProvider.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useState, useMemo } from "react";
+import { createZikade } from "./createZikade"; // <-- corrected import
+const ZikadeContext = createContext(undefined);
+export function ZikadeProvider({ translations, defaultLocale, children }) {
+    const [currentLocale, setCurrentLocale] = useState(defaultLocale);
+    const zikade = useMemo(() => {
+        const instance = createZikade(translations, defaultLocale);
+        instance.setLanguage(currentLocale);
+        return instance;
+    }, [translations, currentLocale, defaultLocale]);
+    const contextValue = useMemo(() => ({
+        zikade,
+        currentLocale,
+        setLanguage: setCurrentLocale // <-- cast here
+    }), [zikade, currentLocale]);
+    return _jsx(ZikadeContext.Provider, { value: contextValue, children: children });
+}
+export { ZikadeContext };

package/dist/createZikade.d.ts

@@ -0,0 +1,7 @@
+import type { LocaleTranslations } from "./types.ts";
+/**
+ * Creates a dot-access, multi-locale translation object with setLanguage()
+ */
+export declare function createZikade<T extends LocaleTranslations>(translations: T, defaultLocale: keyof T): T[keyof T] & {
+    setLanguage: (locale: keyof T) => void;
+};

package/dist/createZikade.js

@@ -0,0 +1,69 @@
+/**
+ * Runtime validation: ensures all locales have the same keys
+ */
+function validateTranslations(translations, baseLocale) {
+    const locales = Object.keys(translations);
+    const base = baseLocale ? translations[baseLocale] : translations[locales[0]];
+    function compareKeys(baseObj, otherObj, path = [], localeName = "") {
+        for (const key of Object.keys(baseObj)) {
+            const fullPath = [...path, key].join(".");
+            if (!(key in otherObj)) {
+                console.error(`[zikade] Missing translation key '${fullPath}' in locale '${localeName}'`);
+            }
+            else if (typeof baseObj[key] === "object" &&
+                typeof otherObj[key] === "object") {
+                compareKeys(baseObj[key], otherObj[key], [...path, key], localeName);
+            }
+        }
+    }
+    for (const locale of locales) {
+        if (translations[locale] !== base) {
+            compareKeys(base, translations[locale], [], locale);
+        }
+    }
+}
+/**
+ * Creates a dot-access, multi-locale translation object with setLanguage()
+ */
+export function createZikade(translations, defaultLocale) {
+    // 1️⃣ Validate translations
+    validateTranslations(translations);
+    // 2️⃣ Current locale
+    let currentLocale = defaultLocale;
+    function setLanguage(locale) {
+        if (!(locale in translations)) {
+            console.warn(`[zikade] Locale '${String(locale)}' not found. Falling back to '${String(defaultLocale)}'.`);
+            currentLocale = defaultLocale;
+        }
+        else {
+            currentLocale = locale;
+        }
+    }
+    // 3️⃣ Recursive proxy that dynamically reads from currentLocale
+    function createProxyForPath(path = []) {
+        return new Proxy({}, {
+            get(_, prop) {
+                const key = typeof prop === "string" ? prop : String(prop);
+                const fullPath = [...path, key];
+                let val = translations[currentLocale];
+                for (const p of fullPath) {
+                    if (val == null)
+                        return key; // fallback if missing
+                    val = val[p];
+                }
+                if (typeof val === "object")
+                    return createProxyForPath(fullPath);
+                return val;
+            }
+        });
+    }
+    const proxy = createProxyForPath();
+    // 4️⃣ Return a proxy that merges setLanguage and top-level translation keys
+    return new Proxy({ setLanguage }, {
+        get(_, prop) {
+            if (prop === "setLanguage")
+                return setLanguage;
+            return proxy[prop];
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./createZikade";
+export * from "./types";
+export * from "./ZikadeProvider";
+export * from "./useZikade";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./createZikade";
+export * from "./types";
+export * from "./ZikadeProvider";
+export * from "./useZikade";

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export type TranslationLeaf = string;
+export type TranslationObject = {
+    [key: string]: TranslationLeaf | TranslationObject;
+};
+export type LocaleTranslations = Record<string, TranslationObject>;

package/dist/types.js

@@ -0,0 +1,2 @@
+// src/types.ts
+export {};

package/dist/useZikade.d.ts

@@ -0,0 +1,4 @@
+import type { LocaleTranslations } from "./types.ts";
+export declare function useZikade<T extends LocaleTranslations>(): ReturnType<any> & {
+    setLanguage: (locale: keyof T) => void;
+};

package/dist/useZikade.js

@@ -0,0 +1,8 @@
+import { useContext } from "react";
+import { ZikadeContext } from "../src/ZikadeProvider.js";
+export function useZikade() {
+    const context = useContext(ZikadeContext);
+    if (!context)
+        throw new Error("useZikade must be used within a ZikadeProvider");
+    return context.zikade;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "zikade",
+  "version": "0.1.0",
+  "author": "Sven_Guettner",
+  "description": "Type-safe, React-compatible internationalization library",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "prepare": "npm run build"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/react": "^19.2.7"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "i18n",
+    "typescript",
+    "react",
+    "internationalization",
+    "translations",
+    "type-safe"
+  ],
+  "license": "MIT"
+}