@delfinjs/core 1.0.0 → 1.0.1

package/dist/{appConfig-hHCWS_gL.js → appConfig-DxhVfL1J.js}

@@ -15,6 +15,6 @@ function e(n) {
   return { ...o, ...d, ..._ };
 }
 export {
-  e as a,
-  t as g
+  t as a,
+  e as g
 };

package/dist/auth/index.js

@@ -1,8 +1,8 @@
 import { parse as s, serialize as u } from "cookie-es";
 import { destr as c } from "destr";
-import { g as f } from "../appConfig-hHCWS_gL.js";
+import { a as f } from "../appConfig-DxhVfL1J.js";
 const r = {};
-function U() {
+function g() {
   if (typeof document > "u") return !1;
   const e = s(document.cookie), n = e.accessToken, t = e.userData;
   if (n)
@@ -76,7 +76,7 @@ function _() {
 }
 export {
   i as getShellUrl,
-  U as isAuthenticated,
+  g as isAuthenticated,
   _ as receiveAuthFromUrl,
   y as redirectToLogin
 };

package/dist/{helpers-CbBec0n2.js → helpers-DMOWsSP3.js}

@@ -10,10 +10,10 @@ const s = (t) => !!(t == null || t === "" || Array.isArray(t) && t.length === 0
   return r;
 };
 export {
-  y as a,
-  i as b,
+  i as a,
+  y as b,
   o as c,
-  c as d,
-  n as e,
+  n as d,
+  c as e,
   s as i
 };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { formatCurrency as a, formatDate as o, formatNumber as t, hexToRgb as i, loadAllMicroUIConfigs as l, loadMicroUIConfig as p, rgbToHex as d } from "./utils/index.js";
-import { e as n, i as f, b as m, a as g, c, d as x } from "./helpers-CbBec0n2.js";
-import { a as A, g as V } from "./appConfig-hHCWS_gL.js";
+import { d as n, i as f, a as m, b as g, c, e as x } from "./helpers-DMOWsSP3.js";
+import { g as A, a as V } from "./appConfig-DxhVfL1J.js";
 import { decrypt as C, encrypt as u, hasCredential as b, parseCredentials as T, parseJwt as U } from "./crypto/index.js";
 import { MFEventTypes as N, eventBus as w } from "./eventBus/index.js";
 import { createAppApi as F, getApiBaseUrl as M } from "./api/index.js";

package/dist/utils/index.js

@@ -1,5 +1,5 @@
-import { e as y, i as _, b as C, a as O, c as U, d as h } from "../helpers-CbBec0n2.js";
-import { a as x, g as N } from "../appConfig-hHCWS_gL.js";
+import { d as y, i as _, a as C, b as O, c as U, e as h } from "../helpers-DMOWsSP3.js";
+import { g as x, a as N } from "../appConfig-DxhVfL1J.js";
 const l = (n) => {
   const e = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
   n = n.replace(e, (r, a, o, i) => a + a + o + o + i + i);

package/dist/validators/index.js

@@ -1,4 +1,4 @@
-import { a as n, b as s, i } from "../helpers-CbBec0n2.js";
+import { i, b as n, a as s } from "../helpers-DMOWsSP3.js";
 const d = (r) => n(r) || s(r) || r === !1 ? "Bu alan zorunludur" : !!String(r).trim().length || "Bu alan zorunludur", l = (r) => {
   if (i(r)) return !0;
   const t = /^(?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*|".+")@(?:\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]|(?:[a-z\-\d]+\.)+[a-z]{2,})$/i;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delfinjs/core",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": false,
   "type": "module",
   "description": "Framework-agnostic shared utilities, event bus, API client, auth helpers, validators, and types for Delfin micro-frontends",
@@ -17,13 +17,10 @@
     "./types": "./src/types/index.js"
   },
   "files": [
+    "src",
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "vite build",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "cookie-es": "^1.2.2",
     "crypto-js": "^4.2.0",
@@ -41,5 +38,8 @@
     "event-bus",
     "api-client"
   ],
-  "license": "UNLICENSED"
-}
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "vite build"
+  }
+}

package/src/api/index.js

@@ -0,0 +1,99 @@
+import { ofetch } from 'ofetch'
+import { eventBus, MFEventTypes } from '../eventBus/index.js'
+import { getAppConfig } from '../utils/appConfig.js'
+
+/**
+ * Resolve the API base URL from runtime config or environment.
+ * @returns {string}
+ */
+export function getApiBaseUrl() {
+  if (typeof window !== 'undefined' && window.__APP_CONFIG__?.VITE_API_BASE_URL) {
+    return window.__APP_CONFIG__.VITE_API_BASE_URL
+  }
+  return (typeof import.meta !== 'undefined' && import.meta.env?.VITE_API_BASE_URL) || '/api'
+}
+
+/**
+ * Framework-agnostic API client factory.
+ *
+ * @param {Object} options
+ * @param {string} [options.baseURL] - API base URL (defaults to runtime config)
+ * @param {string} [options.appSlug] - Micro-UI slug for auto token refresh via event bus
+ * @param {Record<string,string>} [options.headers] - Extra default headers
+ * @param {() => string|null} [options.getToken] - Callback to retrieve the current auth token
+ * @returns {{ (url: string, opts?: any): Promise<any>, setToken: (t: string) => void }}
+ */
+export function createAppApi(options = {}) {
+  const { baseURL, appSlug, headers: customHeaders, getToken } = typeof options === 'string'
+    ? { baseURL: options, appSlug: undefined, headers: undefined, getToken: undefined }
+    : options
+
+  let _token = null
+  let _refreshPromise = null
+
+  function requestTokenRefresh() {
+    if (_refreshPromise) return _refreshPromise
+
+    _refreshPromise = new Promise(resolve => {
+      const timeout = setTimeout(() => {
+        unsubscribe()
+        _refreshPromise = null
+        resolve(null)
+      }, 10_000)
+
+      const unsubscribe = eventBus.on(
+        MFEventTypes.AUTH_MICROUI_TOKEN_REFRESH_RESPONSE,
+        ({ slug, token }) => {
+          if (slug === appSlug) {
+            clearTimeout(timeout)
+            unsubscribe()
+            _token = token
+            _refreshPromise = null
+            resolve(token)
+          }
+        },
+      )
+
+      eventBus.emit(MFEventTypes.AUTH_MICROUI_TOKEN_REFRESH_REQUEST, { slug: appSlug })
+    })
+
+    return _refreshPromise
+  }
+
+  const baseApi = ofetch.create({
+    baseURL: baseURL || getApiBaseUrl(),
+    async onRequest({ options: reqOpts }) {
+      const bearerToken = _token || getToken?.() || null
+      reqOpts.headers = {
+        ...(customHeaders || {}),
+        ...(reqOpts.headers || {}),
+        ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {}),
+      }
+    },
+  })
+
+  const api = async (url, opts) => {
+    try {
+      return await baseApi(url, opts)
+    } catch (error) {
+      if (error?.response?.status === 401 && appSlug) {
+        const newToken = await requestTokenRefresh()
+        if (newToken) {
+          return baseApi(url, {
+            ...opts,
+            headers: {
+              ...(opts?.headers || {}),
+              Authorization: `Bearer ${newToken}`,
+            },
+          })
+        }
+      }
+      throw error
+    }
+  }
+
+  /** Manually set the bearer token (e.g. received from the host). */
+  api.setToken = token => { _token = token }
+
+  return api
+}

package/src/auth/index.js

@@ -0,0 +1,127 @@
+import { parse, serialize } from 'cookie-es'
+import { destr } from 'destr'
+import { getAppConfig } from '../utils/appConfig.js'
+
+/**
+ * Check if user is authenticated by reading cookies.
+ * @returns {boolean}
+ */
+export function isAuthenticated() {
+  if (typeof document === 'undefined') return false
+
+  const cookies = parse(document.cookie)
+  const accessToken = cookies.accessToken
+  const userData = cookies.userData
+
+  if (accessToken) {
+    try {
+      const token = destr(decodeURIComponent(accessToken))
+      return !!token && token !== 'null' && token !== 'undefined'
+    } catch {
+      return false
+    }
+  }
+
+  if (userData) {
+    try {
+      const user = destr(decodeURIComponent(userData))
+      return !!user && typeof user === 'object' && user.id
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+/**
+ * Determine the shell (host) application URL.
+ * @returns {string}
+ */
+export function getShellUrl() {
+  const runtimeHost = getAppConfig('VITE_DELFIN_UI_BASE_URL')
+  if (runtimeHost) return runtimeHost.replace(/\/+$/, '')
+
+  if (typeof window !== 'undefined' && window.location.hostname === 'localhost' && window.location.port !== '3000') {
+    return 'http://localhost:3000'
+  }
+
+  return typeof window !== 'undefined' ? window.location.origin : ''
+}
+
+function isCrossOrigin() {
+  const shellUrl = getShellUrl()
+  try {
+    return typeof window !== 'undefined' && window.location.origin !== new URL(shellUrl).origin
+  } catch {
+    return false
+  }
+}
+
+function getAppSlug() {
+  if (typeof window !== 'undefined' && window.__APP_CONFIG__?.VITE_APP_SLUG)
+    return window.__APP_CONFIG__.VITE_APP_SLUG
+  return typeof import.meta !== 'undefined' ? import.meta.env?.VITE_APP_SLUG : undefined
+}
+
+function cleanAuthParam(url) {
+  try {
+    const u = new URL(url)
+    u.searchParams.delete('_auth')
+    return u.toString()
+  } catch {
+    return url
+  }
+}
+
+function redirectToAuthBridge() {
+  const shellUrl = getShellUrl()
+  const slug = getAppSlug()
+  const currentUrl = cleanAuthParam(window.location.href)
+  const slugParam = slug ? `&slug=${encodeURIComponent(slug)}` : ''
+  window.location.href = `${shellUrl}/auth-bridge?redirect=${encodeURIComponent(currentUrl)}${slugParam}`
+}
+
+/**
+ * Redirect to the shell login page.
+ */
+export function redirectToLogin() {
+  if (typeof window === 'undefined') return
+
+  if (isCrossOrigin()) {
+    redirectToAuthBridge()
+    return
+  }
+
+  const shellUrl = getShellUrl()
+  window.location.href = `${shellUrl}/login?redirect=${encodeURIComponent(window.location.href)}`
+}
+
+/**
+ * Receive auth cookies from the `_auth` query parameter (set by auth-bridge redirect).
+ * Call once at app startup before any route guard runs.
+ * @returns {boolean} true if auth data was received and stored
+ */
+export function receiveAuthFromUrl() {
+  if (typeof window === 'undefined') return false
+
+  const params = new URLSearchParams(window.location.search)
+  const encoded = params.get('_auth')
+  if (!encoded) return false
+
+  try {
+    const authCookies = JSON.parse(atob(decodeURIComponent(encoded)))
+
+    for (const [name, value] of Object.entries(authCookies)) {
+      document.cookie = serialize(name, value, {
+        path: '/',
+        maxAge: 60 * 60 * 24 * 30,
+      })
+    }
+
+    window.history.replaceState(null, '', cleanAuthParam(window.location.href))
+    return true
+  } catch {
+    return false
+  }
+}

package/src/crypto/index.js

@@ -0,0 +1,78 @@
+import CryptoJS from 'crypto-js'
+
+/**
+ * AES-256-CBC encrypt (OpenSSL-compatible, matches .NET CryptoJsCompatDecryptorHelper).
+ * @param {string} plainText
+ * @param {string} passphrase
+ * @returns {string} base64 ciphertext
+ */
+export function encrypt(plainText, passphrase) {
+  return CryptoJS.AES.encrypt(plainText, passphrase).toString()
+}
+
+/**
+ * AES-256-CBC decrypt (OpenSSL-compatible).
+ * @param {string} encryptedBase64
+ * @param {string} passphrase
+ * @returns {string} plaintext
+ */
+export function decrypt(encryptedBase64, passphrase) {
+  const bytes = CryptoJS.AES.decrypt(encryptedBase64, passphrase)
+  return bytes.toString(CryptoJS.enc.Utf8)
+}
+
+/**
+ * Parse a JWT token and return its payload.
+ * @param {string} token
+ * @returns {Record<string, any>}
+ */
+export function parseJwt(token) {
+  const base64Url = token.split('.')[1]
+  const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
+  const jsonPayload = decodeURIComponent(
+    atob(base64)
+      .split('')
+      .map(c => `%${(`00${c.charCodeAt(0).toString(16)}`).slice(-2)}`)
+      .join(''),
+  )
+
+  return JSON.parse(jsonPayload)
+}
+
+/**
+ * Parse JWT credentials claim into a Set of active credential names.
+ * Format: "CredName###1" where 1 = active.
+ * @param {string} token
+ * @returns {Set<string>}
+ */
+export function parseCredentials(token) {
+  if (!token) return new Set()
+
+  try {
+    const payload = parseJwt(token)
+    const raw = payload.credentials
+    if (!Array.isArray(raw)) return new Set()
+
+    const active = new Set()
+    for (const entry of raw) {
+      const [name, value] = entry.split('###')
+      if (value === '1' && name) active.add(name)
+    }
+    return active
+  } catch (err) {
+    console.error('[credentials] Failed to parse JWT credentials:', err)
+    return new Set()
+  }
+}
+
+/**
+ * Check whether a required credential is satisfied.
+ * Returns true if no credential is required.
+ * @param {Set<string>} credentials
+ * @param {string|undefined} required
+ * @returns {boolean}
+ */
+export function hasCredential(credentials, required) {
+  if (!required) return true
+  return credentials.has(required)
+}

package/src/eventBus/index.js

@@ -0,0 +1,119 @@
+/**
+ * Microfrontend Event Types
+ */
+export const MFEventTypes = {
+  AUTH_LOGIN: 'mf:auth:login',
+  AUTH_LOGOUT: 'mf:auth:logout',
+  AUTH_TOKEN_REFRESH: 'mf:auth:token-refresh',
+  AUTH_USER_UPDATE: 'mf:auth:user-update',
+  AUTH_MICROUI_TOKEN_REFRESH_REQUEST: 'mf:auth:microui-token-refresh-request',
+  AUTH_MICROUI_TOKEN_REFRESH_RESPONSE: 'mf:auth:microui-token-refresh-response',
+
+  NAV_ROUTE_CHANGE: 'mf:nav:route-change',
+  NAV_BREADCRUMB_UPDATE: 'mf:nav:breadcrumb-update',
+
+  THEME_CHANGE: 'mf:theme:change',
+  LOCALE_CHANGE: 'mf:locale:change',
+
+  LOADING_START: 'mf:loading:start',
+  LOADING_END: 'mf:loading:end',
+
+  ERROR_GLOBAL: 'mf:error:global',
+  ERROR_AUTH: 'mf:error:auth',
+
+  APP_MOUNTED: 'mf:app:mounted',
+  APP_UNMOUNTED: 'mf:app:unmounted',
+  APP_READY: 'mf:app:ready',
+}
+
+class EventBus {
+  constructor() {
+    this.events = new Map()
+  }
+
+  /**
+   * Subscribe to an event.
+   * @param {string} event
+   * @param {Function} callback
+   * @returns {Function} unsubscribe
+   */
+  on(event, callback) {
+    if (!this.events.has(event)) {
+      this.events.set(event, new Set())
+    }
+    this.events.get(event).add(callback)
+    return () => this.off(event, callback)
+  }
+
+  /**
+   * Subscribe once.
+   * @param {string} event
+   * @param {Function} callback
+   */
+  once(event, callback) {
+    const wrapper = (...args) => {
+      callback(...args)
+      this.off(event, wrapper)
+    }
+    this.on(event, wrapper)
+  }
+
+  /**
+   * Unsubscribe.
+   * @param {string} event
+   * @param {Function} callback
+   */
+  off(event, callback) {
+    if (this.events.has(event)) {
+      this.events.get(event).delete(callback)
+    }
+  }
+
+  /**
+   * Emit an event.
+   * @param {string} event
+   * @param {*} data
+   */
+  emit(event, data) {
+    if (this.events.has(event)) {
+      this.events.get(event).forEach(callback => {
+        try {
+          callback(data)
+        } catch (error) {
+          console.error(`[EventBus] Error in handler for ${event}:`, error)
+        }
+      })
+    }
+
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(event, { detail: data }))
+    }
+  }
+
+  /**
+   * Clear subscriptions.
+   * @param {string} [event] - If omitted, clears all.
+   */
+  clear(event) {
+    if (event) {
+      this.events.delete(event)
+    } else {
+      this.events.clear()
+    }
+  }
+}
+
+/** Singleton EventBus instance */
+export const eventBus = new EventBus()
+
+if (typeof window !== 'undefined') {
+  Object.values(MFEventTypes).forEach(eventType => {
+    window.addEventListener(eventType, event => {
+      if (!event._fromEventBus) {
+        eventBus.events.get(eventType)?.forEach(callback => {
+          callback(event.detail)
+        })
+      }
+    })
+  })
+}

package/src/index.js

@@ -0,0 +1,65 @@
+// Utils
+export {
+  hexToRgb,
+  rgbToHex,
+  formatDate,
+  formatCurrency,
+  formatNumber,
+  isEmpty,
+  isNullOrUndefined,
+  isEmptyArray,
+  isObject,
+  isToday,
+  deepClone,
+  getAppConfig,
+  getAllAppConfig,
+  loadMicroUIConfig,
+  loadAllMicroUIConfigs,
+} from './utils/index.js'
+
+// Crypto & Credentials
+export {
+  encrypt,
+  decrypt,
+  parseJwt,
+  parseCredentials,
+  hasCredential,
+} from './crypto/index.js'
+
+// Event Bus
+export { eventBus, MFEventTypes } from './eventBus/index.js'
+
+// API Client
+export { createAppApi, getApiBaseUrl } from './api/index.js'
+
+// Auth Helpers
+export {
+  isAuthenticated,
+  getShellUrl,
+  redirectToLogin,
+  receiveAuthFromUrl,
+} from './auth/index.js'
+
+// Validators
+export {
+  requiredValidator,
+  emailValidator,
+  passwordValidator,
+  confirmedValidator,
+  betweenValidator,
+  integerValidator,
+  regexValidator,
+  alphaValidator,
+  urlValidator,
+  lengthValidator,
+  alphaDashValidator,
+} from './validators/index.js'
+
+// Types & Enums
+export {
+  AppContentLayoutNav,
+  ContentWidth,
+  NavbarType,
+  FooterType,
+  Skins,
+} from './types/index.js'

package/src/types/index.js

@@ -0,0 +1,72 @@
+/**
+ * @typedef {Object} ThemeConfig
+ * @property {string} theme - 'light' | 'dark' | 'system'
+ * @property {boolean} isVerticalNavCollapsed
+ * @property {string} contentWidth - 'boxed' | 'fluid'
+ * @property {string} contentLayoutNav - 'vertical' | 'horizontal'
+ * @property {boolean} isVerticalNavSemiDark
+ * @property {boolean} isAppRTL
+ * @property {string} navbarType - 'sticky' | 'static' | 'hidden'
+ * @property {string} footerType - 'sticky' | 'static' | 'hidden'
+ * @property {boolean} navbarBlur
+ */
+
+/**
+ * @typedef {Object} UserData
+ * @property {string|number} id
+ * @property {string} fullName
+ * @property {string} username
+ * @property {string} email
+ * @property {string} avatar
+ * @property {string} role
+ */
+
+/**
+ * @typedef {Object} AbilityRule
+ * @property {string} action
+ * @property {string} subject
+ */
+
+/**
+ * @typedef {Object} NavItem
+ * @property {string} title
+ * @property {string} [to]
+ * @property {Object} [icon]
+ * @property {NavItem[]} [children]
+ * @property {string} [heading]
+ */
+
+/**
+ * @typedef {Object} MFAppConfig
+ * @property {string} name
+ * @property {string} url
+ * @property {string} scope
+ * @property {string} module
+ */
+
+export const AppContentLayoutNav = {
+  Vertical: 'vertical',
+  Horizontal: 'horizontal',
+}
+
+export const ContentWidth = {
+  Boxed: 'boxed',
+  Fluid: 'fluid',
+}
+
+export const NavbarType = {
+  Sticky: 'sticky',
+  Static: 'static',
+  Hidden: 'hidden',
+}
+
+export const FooterType = {
+  Sticky: 'sticky',
+  Static: 'static',
+  Hidden: 'hidden',
+}
+
+export const Skins = {
+  Default: 'default',
+  Bordered: 'bordered',
+}

package/src/utils/appConfig.js

@@ -0,0 +1,35 @@
+/**
+ * Runtime configuration loader.
+ *
+ * Host app (Docker/K8s): reads from window.__APP_CONFIG__
+ * Micro-UI (loaded in host): reads from window.__MICROUI_CONFIG__[slug]
+ * Development (local): falls back to import.meta.env
+ *
+ * @param {string} key - Config key (e.g., 'VITE_API_BASE_URL')
+ * @param {string} [appSlug] - Optional micro-UI slug for namespaced config
+ * @returns {string|undefined}
+ */
+export function getAppConfig(key, appSlug) {
+  if (typeof window !== 'undefined') {
+    if (appSlug && window.__MICROUI_CONFIG__?.[appSlug]?.[key] !== undefined)
+      return window.__MICROUI_CONFIG__[appSlug][key]
+
+    if (window.__APP_CONFIG__?.[key] !== undefined)
+      return window.__APP_CONFIG__[key]
+  }
+
+  return typeof import.meta !== 'undefined' ? import.meta.env?.[key] : undefined
+}
+
+/**
+ * Get all app configuration merged (build-time + host + micro-UI).
+ * @param {string} [appSlug]
+ * @returns {Record<string, string>}
+ */
+export function getAllAppConfig(appSlug) {
+  const buildConfig = (typeof import.meta !== 'undefined' && import.meta.env) || {}
+  const hostConfig = (typeof window !== 'undefined' && window.__APP_CONFIG__) || {}
+  const microConfig = (typeof window !== 'undefined' && appSlug && window.__MICROUI_CONFIG__?.[appSlug]) || {}
+
+  return { ...buildConfig, ...hostConfig, ...microConfig }
+}

package/src/utils/colorConverter.js

@@ -0,0 +1,31 @@
+/**
+ * Convert hex color to RGB string
+ * @param {string} hex - Hex color string (e.g., '#ff0000' or 'ff0000')
+ * @returns {string|null} RGB string (e.g., '255, 0, 0')
+ */
+export const hexToRgb = hex => {
+  const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i
+  hex = hex.replace(shorthandRegex, (m, r, g, b) => r + r + g + g + b + b)
+
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+
+  return result
+    ? `${parseInt(result[1], 16)}, ${parseInt(result[2], 16)}, ${parseInt(result[3], 16)}`
+    : null
+}
+
+/**
+ * Convert RGB values to hex color string
+ * @param {number} r - Red (0-255)
+ * @param {number} g - Green (0-255)
+ * @param {number} b - Blue (0-255)
+ * @returns {string} Hex color string (e.g., '#ff0000')
+ */
+export const rgbToHex = (r, g, b) => {
+  const toHex = c => {
+    const hex = c.toString(16)
+    return hex.length === 1 ? '0' + hex : hex
+  }
+
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`
+}

package/src/utils/formatters.js

@@ -0,0 +1,42 @@
+/**
+ * Format date to locale string
+ * @param {Date|string|number} date
+ * @param {string} [locale='en-US']
+ * @param {Intl.DateTimeFormatOptions} [options={}]
+ * @returns {string}
+ */
+export const formatDate = (date, locale = 'en-US', options = {}) => {
+  const defaultOptions = {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    ...options,
+  }
+
+  return new Intl.DateTimeFormat(locale, defaultOptions).format(new Date(date))
+}
+
+/**
+ * Format number as currency
+ * @param {number} value
+ * @param {string} [currency='USD']
+ * @param {string} [locale='en-US']
+ * @returns {string}
+ */
+export const formatCurrency = (value, currency = 'USD', locale = 'en-US') => {
+  return new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+  }).format(value)
+}
+
+/**
+ * Format number with locale
+ * @param {number} value
+ * @param {string} [locale='en-US']
+ * @param {Intl.NumberFormatOptions} [options={}]
+ * @returns {string}
+ */
+export const formatNumber = (value, locale = 'en-US', options = {}) => {
+  return new Intl.NumberFormat(locale, options).format(value)
+}

package/src/utils/helpers.js

@@ -0,0 +1,56 @@
+/**
+ * Check if value is empty (null, undefined, empty string, empty array, empty object)
+ * @param {*} value
+ * @returns {boolean}
+ */
+export const isEmpty = value => {
+  if (value === null || value === undefined || value === '') return true
+  if (Array.isArray(value) && value.length === 0) return true
+  if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) return true
+  return false
+}
+
+/** @param {*} value */
+export const isNullOrUndefined = value => value === null || value === undefined
+
+/** @param {*} arr */
+export const isEmptyArray = arr => Array.isArray(arr) && arr.length === 0
+
+/**
+ * Check if value is a plain object (not array, not null)
+ * @param {*} value
+ * @returns {boolean}
+ */
+export const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+
+/**
+ * Check if a Date is today
+ * @param {Date} date
+ * @returns {boolean}
+ */
+export const isToday = date => {
+  const today = new Date()
+  return (
+    date.getDate() === today.getDate() &&
+    date.getMonth() === today.getMonth() &&
+    date.getFullYear() === today.getFullYear()
+  )
+}
+
+/**
+ * Deep clone an object
+ * @param {*} obj
+ * @returns {*}
+ */
+export const deepClone = obj => {
+  if (obj === null || typeof obj !== 'object') return obj
+  if (Array.isArray(obj)) return obj.map(deepClone)
+
+  const cloned = {}
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key])
+    }
+  }
+  return cloned
+}

package/src/utils/index.js

@@ -0,0 +1,5 @@
+export { hexToRgb, rgbToHex } from './colorConverter.js'
+export { formatDate, formatCurrency, formatNumber } from './formatters.js'
+export { isEmpty, isNullOrUndefined, isEmptyArray, isObject, isToday, deepClone } from './helpers.js'
+export { getAppConfig, getAllAppConfig } from './appConfig.js'
+export { loadMicroUIConfig, loadAllMicroUIConfigs } from './microuiConfigLoader.js'

package/src/utils/microuiConfigLoader.js

@@ -0,0 +1,70 @@
+/**
+ * Fetches each micro-UI's /config.js from its container origin,
+ * parses the JSON object from it, and stores it under
+ * window.__MICROUI_CONFIG__[slug].
+ */
+
+if (typeof window !== 'undefined' && !window.__MICROUI_CONFIG__) {
+  window.__MICROUI_CONFIG__ = {}
+}
+
+function extractOrigin(remoteUrl) {
+  try {
+    return new URL(remoteUrl).origin
+  } catch {
+    return null
+  }
+}
+
+function parseConfigJs(text) {
+  const start = text.indexOf('{')
+  const end = text.lastIndexOf('}')
+  if (start === -1 || end === -1) return null
+
+  try {
+    return JSON.parse(text.slice(start, end + 1))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Load a single micro-UI's runtime config from its container.
+ * @param {string} slug
+ * @param {string} remoteUrl - The remoteEntry.js URL (used to derive origin)
+ * @returns {Promise<Record<string, string>|null>}
+ */
+export async function loadMicroUIConfig(slug, remoteUrl) {
+  const origin = extractOrigin(remoteUrl)
+  if (!origin) return null
+
+  try {
+    const response = await fetch(`${origin}/config.js`, { cache: 'no-cache' })
+    if (!response.ok) return null
+
+    const text = await response.text()
+    const config = parseConfigJs(text)
+    if (config && typeof window !== 'undefined') {
+      window.__MICROUI_CONFIG__[slug] = config
+    }
+
+    return config
+  } catch {
+    console.warn(`[MicroUIConfig] Failed to load config for ${slug} from ${origin}/config.js`)
+    return null
+  }
+}
+
+/**
+ * Load runtime configs for all registered micro-UIs in parallel.
+ * @param {Record<string, { remoteUrl: string }>} microuiConfig
+ * @returns {Promise<void>}
+ */
+export async function loadAllMicroUIConfigs(microuiConfig) {
+  const entries = Object.entries(microuiConfig)
+  if (entries.length === 0) return
+
+  await Promise.allSettled(
+    entries.map(([slug, config]) => loadMicroUIConfig(slug, config.remoteUrl)),
+  )
+}

package/src/validators/index.js

@@ -0,0 +1,68 @@
+import { isEmpty, isNullOrUndefined, isEmptyArray } from '../utils/helpers.js'
+
+export const requiredValidator = value => {
+  if (isNullOrUndefined(value) || isEmptyArray(value) || value === false)
+    return 'Bu alan zorunludur'
+
+  return !!String(value).trim().length || 'Bu alan zorunludur'
+}
+
+export const emailValidator = value => {
+  if (isEmpty(value)) return true
+  const re = /^(?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*|".+")@(?:\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]|(?:[a-z\-\d]+\.)+[a-z]{2,})$/i
+  if (Array.isArray(value))
+    return value.every(val => re.test(String(val))) || 'Gecerli bir e-posta adresi girin'
+
+  return re.test(String(value)) || 'Gecerli bir e-posta adresi girin'
+}
+
+export const passwordValidator = password => {
+  const regExp = /(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%&*()]).{8,}/
+  return regExp.test(password) || 'Alan en az bir buyuk harf, kucuk harf, ozel karakter ve rakam icermeli ve en az 8 karakter uzunlugunda olmalidir'
+}
+
+export const confirmedValidator = (value, target) =>
+  value === target || 'Sifreler eslesmedi'
+
+export const betweenValidator = (value, min, max) => {
+  const n = Number(value)
+  return (Number(min) <= n && Number(max) >= n) || `${min} ve ${max} arasi bir deger girin`
+}
+
+export const integerValidator = value => {
+  if (isEmpty(value)) return true
+  if (Array.isArray(value))
+    return value.every(val => /^-?\d+$/.test(String(val))) || 'Bu alan tam sayi olmalidir'
+
+  return /^-?\d+$/.test(String(value)) || 'Bu alan tam sayi olmalidir'
+}
+
+export const regexValidator = (value, regex) => {
+  if (isEmpty(value)) return true
+  let re = regex
+  if (typeof re === 'string') re = new RegExp(re)
+  if (Array.isArray(value)) return value.every(val => regexValidator(val, re))
+
+  return re.test(String(value)) || 'Gecersiz format'
+}
+
+export const alphaValidator = value => {
+  if (isEmpty(value)) return true
+  return /^[A-Z]*$/i.test(String(value)) || 'Sadece harf karakterleri kullanilaabilir'
+}
+
+export const urlValidator = value => {
+  if (isEmpty(value)) return true
+  const re = /^https?:\/\/[^\s$.?#].\S*$/
+  return re.test(String(value)) || 'Gecersiz URL'
+}
+
+export const lengthValidator = (value, length) => {
+  if (isEmpty(value)) return true
+  return String(value).length === length || `Karakter uzunlugu ${length} karakter olmalidir`
+}
+
+export const alphaDashValidator = value => {
+  if (isEmpty(value)) return true
+  return /^[\w-]*$/.test(String(value)) || 'Gecersiz karakter'
+}