md-face-engine 1.0.0

package/README.md

@@ -0,0 +1,37 @@
+# md-face-engine
+
+Motor reusable para detección facial y aplicación de filtros.
+
+## Instalación
+
+```bash
+npm install md-face-engine
+```
+
+## Uso en frontend
+
+```js
+import { createMdFaceEngineClient } from 'md-face-engine/client';
+
+const client = createMdFaceEngineClient({
+  token: import.meta.env.VITE_MD_FACE_ENGINE_TOKEN,
+  products: []
+});
+```
+
+El frontend solo necesita un valor:
+
+- `VITE_MD_FACE_ENGINE_TOKEN`
+
+## Build del paquete
+
+```bash
+npm run build
+```
+
+## Publicar en npm
+
+```bash
+npm login
+npm publish --access public
+```

package/dist/client-BGSZMMvf.js

@@ -0,0 +1,620 @@
+const wrinkles = {
+  key: "wrinkles",
+  label: "Arrugas",
+  defaults: { intensity: 0.5, sigma: 4, brightness: 0 },
+  deep: {
+    smooth: { enabled: true, radius: 8, passes: 4, opacity: 0.7 },
+    brightness: { enabled: true, value: 10 },
+    contrast: { enabled: true, value: 1.03 },
+    warmth: { enabled: true, rPlus: 8, bMinus: 5, alpha: 0.3 },
+    toneUnify: { enabled: true, threshold: 12, mix: 0.4 },
+    blemish: { enabled: true, microBlur: 3, alpha: 0.4 },
+    contourLift: { enabled: true, lift: 0.06, shade: 0.04, feather: 20 }
+  }
+};
+const brightness = {
+  key: "brightness",
+  label: "Luminosidad",
+  defaults: { intensity: 0, sigma: 0, brightness: 0.07 },
+  deep: {
+    smooth: { enabled: true, radius: 5, passes: 3, opacity: 0.5 },
+    brightness: { enabled: true, value: 18 },
+    contrast: { enabled: true, value: 1.15 },
+    warmth: { enabled: true, rPlus: 12, bMinus: 8, alpha: 0.45 },
+    toneUnify: { enabled: true, threshold: 10, mix: 0.3 },
+    blemish: { enabled: true, microBlur: 2, alpha: 0.3 },
+    contourLift: { enabled: true, lift: 0.12, shade: 0.08, feather: 18 }
+  }
+};
+const spots = {
+  key: "spots",
+  label: "Manchas/Tono",
+  defaults: { intensity: 0.65, sigma: 5, brightness: 0.05 },
+  deep: {
+    smooth: { enabled: true, radius: 6, passes: 3, opacity: 0.6 },
+    brightness: { enabled: true, value: 12 },
+    contrast: { enabled: true, value: 1.08 },
+    warmth: { enabled: true, rPlus: 7, bMinus: 4, alpha: 0.3 },
+    toneUnify: { enabled: true, threshold: 8, mix: 0.6 },
+    blemish: { enabled: true, microBlur: 4, alpha: 0.5 },
+    contourLift: { enabled: true, lift: 0.08, shade: 0.06, feather: 16 }
+  }
+};
+const acne = {
+  key: "acne",
+  label: "Acné",
+  defaults: { intensity: 0.55, sigma: 3.4, brightness: 0.1 },
+  deep: {
+    smooth: { enabled: true, radius: 7, passes: 4, opacity: 0.65 },
+    brightness: { enabled: true, value: 8 },
+    contrast: { enabled: true, value: 1.02 },
+    warmth: { enabled: true, rPlus: 6, bMinus: 3, alpha: 0.25 },
+    toneUnify: { enabled: true, threshold: 10, mix: 0.5 },
+    blemish: { enabled: true, microBlur: 5, alpha: 0.7 },
+    contourLift: { enabled: true, lift: 0.06, shade: 0.04, feather: 20 }
+  }
+};
+const firmness = {
+  key: "firmness",
+  label: "Firmeza",
+  defaults: { intensity: 0.7, sigma: 2, brightness: 0 },
+  deep: {
+    smooth: { enabled: true, radius: 3, passes: 2, opacity: 0.3 },
+    brightness: { enabled: true, value: 6 },
+    contrast: { enabled: true, value: 1.12 },
+    warmth: { enabled: true, rPlus: 5, bMinus: 3, alpha: 0.2 },
+    toneUnify: { enabled: true, threshold: 18, mix: 0.2 },
+    blemish: { enabled: false, microBlur: 1, alpha: 0.1 },
+    contourLift: { enabled: true, lift: 0.15, shade: 0.12, feather: 12 }
+  }
+};
+const FILTERS = {
+  wrinkles,
+  brightness,
+  spots,
+  acne,
+  firmness
+};
+function getFilter(key) {
+  return FILTERS[key] || null;
+}
+const FILTER_ORDER = ["wrinkles", "brightness", "spots", "acne", "firmness"];
+const DEFAULT_FILTER_CONFIG = {
+  // 1) Arrugas → Suavizado de piel
+  smooth: {
+    enabled: true,
+    intensity: 36,
+    // referencia visual
+    radius: 4,
+    passes: 2,
+    opacity: 0.4
+  },
+  // 2) Piel apagada → Brillo
+  brightness: {
+    enabled: true,
+    intensity: 91,
+    // referencia visual
+    value: 8
+  },
+  // Ajuste de contraste general
+  contrast: {
+    enabled: true,
+    intensity: 10,
+    value: 1.05
+  },
+  // Tono cálido / glow
+  warmth: {
+    enabled: true,
+    intensity: 20,
+    rPlus: 6,
+    bMinus: 4,
+    alpha: 0.25
+  },
+  // 2) Manchas → Unificar tono
+  toneUnify: {
+    enabled: true,
+    intensity: 65,
+    // referencia visual
+    threshold: 15,
+    mix: 0.25
+  },
+  // 5) Acné → Reducir imperfecciones
+  blemish: {
+    enabled: true,
+    intensity: 35,
+    // referencia visual
+    microBlur: 2,
+    alpha: 0.25
+  },
+  // 3) Firmeza → Lifting y contouring
+  contourLift: {
+    enabled: true,
+    intensity: 24,
+    // referencia visual
+    lift: 0.08,
+    shade: 0.06,
+    feather: 15
+  },
+  // Extras
+  highlights: {
+    enabled: false,
+    intensity: 10
+  },
+  shadows: {
+    enabled: false,
+    intensity: 5
+  }
+};
+const CONCERN_PRESETS = {
+  arrugas: {
+    smooth: { enabled: true, intensity: 36, radius: 6, passes: 3, opacity: 0.6 },
+    contourLift: { enabled: true, intensity: 20, lift: 0.06, shade: 0.05, feather: 18 }
+  },
+  manchas: {
+    toneUnify: { enabled: true, intensity: 65, threshold: 14, mix: 0.35 },
+    brightness: { enabled: true, intensity: 20, value: 10 }
+  },
+  firmeza: {
+    contourLift: { enabled: true, intensity: 24, lift: 0.08, shade: 0.06, feather: 20 },
+    contrast: { enabled: true, intensity: 12, value: 1.07 }
+  },
+  luminosidad: {
+    brightness: { enabled: true, intensity: 91, value: 12 },
+    warmth: { enabled: true, intensity: 25, rPlus: 8, bMinus: 5, alpha: 0.3 }
+  },
+  acne: {
+    blemish: { enabled: true, intensity: 35, microBlur: 3, alpha: 0.35 },
+    toneUnify: { enabled: true, intensity: 40, threshold: 16, mix: 0.3 }
+  }
+};
+const CATEGORY_PRESETS = {
+  // Antiaging: foco en arrugas y firmeza
+  antiaging: {
+    smooth: { enabled: true, intensity: 36, radius: 6, passes: 3, opacity: 0.6 },
+    contourLift: { enabled: true, intensity: 24, lift: 0.07, shade: 0.05, feather: 18 },
+    brightness: { enabled: true, intensity: 20, value: 10 },
+    warmth: { enabled: true, intensity: 22, rPlus: 7, bMinus: 5, alpha: 0.28 }
+  },
+  // Manchas / pigmentación: foco en unificar tono y luminosidad
+  manchas: {
+    toneUnify: { enabled: true, intensity: 65, threshold: 14, mix: 0.35 },
+    brightness: { enabled: true, intensity: 25, value: 10 },
+    warmth: { enabled: false }
+  },
+  // Hidratación: suavizado ligero y glow moderado
+  hidratacion: {
+    smooth: { enabled: true, intensity: 25, radius: 3, passes: 2, opacity: 0.35 },
+    brightness: { enabled: true, intensity: 18, value: 8 },
+    warmth: { enabled: true, intensity: 15, rPlus: 5, bMinus: 3, alpha: 0.2 }
+  },
+  // Acné: foco en reducción de imperfecciones y tono uniforme
+  acne: {
+    blemish: { enabled: true, intensity: 35, microBlur: 3, alpha: 0.35 },
+    toneUnify: { enabled: true, intensity: 40, threshold: 16, mix: 0.3 },
+    brightness: { enabled: false }
+  }
+};
+class FilterConfigManager {
+  constructor(options = {}) {
+    this.storageKey = "martiderm_filter_configs";
+    this.authKey = "martiderm_admin_auth";
+    this.backupKey = "martiderm_config_backup";
+    this.products = Array.isArray(options.products) ? options.products : [];
+    this.init();
+  }
+  /**
+   * Inicializa el gestor de configuraciones
+   */
+  init() {
+    const savedConfigs = this.loadConfigurations();
+    if ((!savedConfigs || Object.keys(savedConfigs).length === 0) && this.products.length > 0) {
+      this.initializeDefaultConfigurations();
+    }
+  }
+  setProducts(products = []) {
+    this.products = Array.isArray(products) ? products : [];
+    const savedConfigs = this.loadConfigurations();
+    if ((!savedConfigs || Object.keys(savedConfigs).length === 0) && this.products.length > 0) {
+      this.initializeDefaultConfigurations();
+    }
+  }
+  /**
+   * Inicializa configuraciones predeterminadas para todos los productos
+   */
+  initializeDefaultConfigurations() {
+    try {
+      const configs = {};
+      this.products.forEach((product) => {
+        configs[product.id] = this.generateProductConfig(product);
+      });
+      this.saveConfigurations(configs);
+    } catch (error) {
+      console.error("Error inicializando configuraciones:", error);
+    }
+  }
+  /**
+   * Genera configuración específica para un producto
+   */
+  generateProductConfig(product) {
+    const baseConfig = { ...DEFAULT_FILTER_CONFIG };
+    const categoryPreset = CATEGORY_PRESETS[product.category];
+    if (categoryPreset) {
+      Object.keys(categoryPreset).forEach((filterType) => {
+        if (baseConfig[filterType]) {
+          baseConfig[filterType] = {
+            ...baseConfig[filterType],
+            ...categoryPreset[filterType]
+          };
+        }
+      });
+    }
+    if (product.targetConcerns && Array.isArray(product.targetConcerns)) {
+      product.targetConcerns.forEach((concern) => {
+        const preset = CONCERN_PRESETS[concern];
+        if (preset) {
+          Object.keys(preset).forEach((filterType) => {
+            if (baseConfig[filterType]) {
+              baseConfig[filterType] = {
+                ...baseConfig[filterType],
+                ...preset[filterType]
+              };
+            }
+          });
+        }
+      });
+    }
+    return {
+      productId: product.id,
+      productName: product.name,
+      category: product.category,
+      filters: baseConfig,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0"
+    };
+  }
+  /**
+   * Obtiene la configuración de filtros para un producto específico
+   */
+  getProductConfig(productId) {
+    const configs = this.loadConfigurations();
+    return configs[productId] || null;
+  }
+  /**
+   * Guarda la configuración de filtros para un producto
+   */
+  saveProductConfig(productId, config) {
+    const configs = this.loadConfigurations();
+    configs[productId] = {
+      ...config,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveConfigurations(configs);
+    return true;
+  }
+  /**
+   * Obtiene todas las configuraciones
+   */
+  getAllConfigurations() {
+    return this.loadConfigurations();
+  }
+  /**
+   * Carga configuraciones desde localStorage
+   */
+  loadConfigurations() {
+    try {
+      const saved = localStorage.getItem(this.storageKey);
+      return saved ? JSON.parse(saved) : {};
+    } catch (error) {
+      console.error("Error cargando configuraciones:", error);
+      return {};
+    }
+  }
+  /**
+   * Guarda configuraciones en localStorage
+   */
+  saveConfigurations(configs) {
+    try {
+      localStorage.setItem(this.storageKey, JSON.stringify(configs));
+      this.createBackup(configs);
+      return true;
+    } catch (error) {
+      console.error("Error guardando configuraciones:", error);
+      return false;
+    }
+  }
+  /**
+   * Crea un backup de las configuraciones
+   */
+  createBackup(configs = null) {
+    try {
+      const configsToBackup = configs || this.loadConfigurations();
+      const backup = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        configurations: configsToBackup,
+        version: "1.0"
+      };
+      localStorage.setItem(this.backupKey, JSON.stringify(backup));
+      return true;
+    } catch (error) {
+      console.error("Error creando backup:", error);
+      return false;
+    }
+  }
+  /**
+   * Restaura configuraciones desde backup
+   */
+  restoreFromBackup() {
+    try {
+      const backup = localStorage.getItem(this.backupKey);
+      if (backup) {
+        const backupData = JSON.parse(backup);
+        this.saveConfigurations(backupData.configurations);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error restaurando backup:", error);
+      return false;
+    }
+  }
+  /**
+   * Exporta configuraciones para descarga
+   */
+  exportConfigurations() {
+    const configs = this.loadConfigurations();
+    const exportData = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      configurations: configs,
+      version: "1.0"
+    };
+    return JSON.stringify(exportData, null, 2);
+  }
+  /**
+   * Importa configuraciones desde archivo
+   */
+  importConfigurations(jsonData) {
+    try {
+      const importData = JSON.parse(jsonData);
+      if (importData.configurations) {
+        this.saveConfigurations(importData.configurations);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error importando configuraciones:", error);
+      return false;
+    }
+  }
+  /**
+   * Resetea configuraciones a valores predeterminados
+   */
+  resetToDefaults() {
+    try {
+      localStorage.removeItem(this.storageKey);
+      this.initializeDefaultConfigurations();
+      return true;
+    } catch (error) {
+      console.error("Error reseteando configuraciones:", error);
+      return false;
+    }
+  }
+  /**
+   * Estado de autenticación del administrador
+   */
+  isAuthenticated() {
+    try {
+      const raw = localStorage.getItem(this.authKey);
+      if (!raw) return false;
+      const data = JSON.parse(raw);
+      return !!(data == null ? void 0 : data.authenticated);
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Autentica al administrador con credenciales simples de demo
+   */
+  authenticateAdmin(username, password) {
+    const validUser = username === "admin";
+    const validPass = password === "martiderm2024";
+    if (validUser && validPass) {
+      const session = {
+        authenticated: true,
+        username,
+        token: `adm-${Date.now()}`,
+        lastLogin: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      localStorage.setItem(this.authKey, JSON.stringify(session));
+      return { success: true, username };
+    }
+    return { success: false, error: "Credenciales inválidas" };
+  }
+  /**
+   * Obtiene información del usuario autenticado
+   */
+  getAuthenticatedUser() {
+    try {
+      const raw = localStorage.getItem(this.authKey);
+      if (!raw) return null;
+      const data = JSON.parse(raw);
+      if (data == null ? void 0 : data.authenticated) {
+        return { username: data.username };
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Cierra sesión del administrador
+   */
+  logout() {
+    try {
+      localStorage.removeItem(this.authKey);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Compatibilidad: método singular usado por AdminPanel
+   */
+  exportConfiguration() {
+    return this.exportConfigurations();
+  }
+}
+const filterConfigManager = new FilterConfigManager();
+function buildWebglConfigForProduct(product) {
+  var _a, _b, _c, _d;
+  const pc = filterConfigManager.getProductConfig(product.id) || {};
+  const lockedType = product.filterType || pc.webglConfig && pc.webglConfig.filterType || "wrinkles";
+  const defaults = FILTERS[lockedType] && FILTERS[lockedType].defaults || { intensity: 0.5, sigma: 4, brightness: 0 };
+  const deep = FILTERS[lockedType] && FILTERS[lockedType].deep || {};
+  const base = {
+    filterType: lockedType,
+    intensity: product.defaultIntensity !== void 0 ? product.defaultIntensity : defaults.intensity,
+    sigma: product.defaultSigma !== void 0 ? product.defaultSigma : defaults.sigma,
+    brightness: product.defaultBrightness !== void 0 ? product.defaultBrightness : defaults.brightness,
+    contrast: typeof ((_a = deep.contrast) == null ? void 0 : _a.value) === "number" ? deep.contrast.value : 1,
+    warmthR: typeof ((_b = deep.warmth) == null ? void 0 : _b.rPlus) === "number" ? deep.warmth.rPlus : 0,
+    warmthB: typeof ((_c = deep.warmth) == null ? void 0 : _c.bMinus) === "number" ? deep.warmth.bMinus : 0,
+    warmthA: typeof ((_d = deep.warmth) == null ? void 0 : _d.alpha) === "number" ? deep.warmth.alpha : 0
+  };
+  const adminCfg = pc.webglConfig || {};
+  return { ...base, ...adminCfg, filterType: lockedType };
+}
+const TOKEN_PREFIX = "mdfe_";
+const PRODUCT_CODE = "md-face-engine";
+const LICENSE_SECRET = "md-face-engine-license-v1";
+function hashToken(value) {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i += 1) {
+    hash = (hash << 5) + hash + value.charCodeAt(i);
+    hash &= 4294967295;
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function decodeBase64Url(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = normalized.length % 4;
+  const padded = padding ? normalized + "=".repeat(4 - padding) : normalized;
+  return atob(padded);
+}
+function validateLicenseToken(token, options = {}) {
+  const { now = Date.now() } = options;
+  if (!token || typeof token !== "string") {
+    return { valid: false, reason: "Token vacío o inválido" };
+  }
+  if (!token.startsWith(TOKEN_PREFIX)) {
+    return { valid: false, reason: "Prefijo de token inválido" };
+  }
+  const raw = token.slice(TOKEN_PREFIX.length);
+  const parts = raw.split(".");
+  if (parts.length !== 2) {
+    return { valid: false, reason: "Formato de token inválido" };
+  }
+  const [payloadPart, signature] = parts;
+  const expected = hashToken(`${payloadPart}.${LICENSE_SECRET}`);
+  if (signature !== expected) {
+    return { valid: false, reason: "Firma de licencia inválida" };
+  }
+  let payload;
+  try {
+    payload = JSON.parse(decodeBase64Url(payloadPart));
+  } catch (_err) {
+    return { valid: false, reason: "Payload de licencia inválido" };
+  }
+  if (payload.productCode !== PRODUCT_CODE) {
+    return { valid: false, reason: "Licencia de otro producto" };
+  }
+  if (typeof payload.exp !== "number" || payload.exp < now) {
+    return { valid: false, reason: "Licencia vencida" };
+  }
+  return { valid: true, reason: null, payload };
+}
+class MdFaceEngine {
+  constructor() {
+    this.license = null;
+    this.activated = false;
+  }
+  activate(token) {
+    const result = validateLicenseToken(token);
+    if (!result.valid) {
+      this.license = null;
+      this.activated = false;
+      throw new Error(`Licencia inválida: ${result.reason}`);
+    }
+    this.license = result.payload;
+    this.activated = true;
+    return result.payload;
+  }
+  isActivated() {
+    return this.activated;
+  }
+  assertActivated() {
+    if (!this.activated) {
+      throw new Error("md-face-engine no está activado. Configura VITE_MD_FACE_ENGINE_TOKEN.");
+    }
+  }
+  getLicense() {
+    this.assertActivated();
+    return this.license;
+  }
+  getProductCode() {
+    return PRODUCT_CODE;
+  }
+  getFilterRegistry() {
+    this.assertActivated();
+    return FILTERS;
+  }
+  getFilterOrder() {
+    this.assertActivated();
+    return FILTER_ORDER;
+  }
+  getFilter(key) {
+    this.assertActivated();
+    return getFilter(key);
+  }
+  getFilterConfigManager() {
+    this.assertActivated();
+    return filterConfigManager;
+  }
+  buildWebglConfigForProduct(product) {
+    this.assertActivated();
+    return buildWebglConfigForProduct(product);
+  }
+}
+function createMdFaceEngineClient({ token, products = [] } = {}) {
+  if (!token) {
+    throw new Error("Falta token de licencia para activar md-face-engine.");
+  }
+  const engine = new MdFaceEngine();
+  engine.activate(token);
+  engine.assertActivated();
+  const filterConfigManager2 = engine.getFilterConfigManager();
+  if (Array.isArray(products)) {
+    filterConfigManager2.setProducts(products);
+  }
+  return {
+    engine,
+    FILTERS: engine.getFilterRegistry(),
+    FILTER_ORDER: engine.getFilterOrder(),
+    getFilter: (key) => engine.getFilter(key),
+    filterConfigManager: filterConfigManager2,
+    buildWebglConfigForProduct: (product) => engine.buildWebglConfigForProduct(product)
+  };
+}
+export {
+  CATEGORY_PRESETS as C,
+  DEFAULT_FILTER_CONFIG as D,
+  FILTERS as F,
+  MdFaceEngine as M,
+  FILTER_ORDER as a,
+  FilterConfigManager as b,
+  createMdFaceEngineClient as c,
+  buildWebglConfigForProduct as d,
+  filterConfigManager as f,
+  getFilter as g,
+  validateLicenseToken as v
+};
+//# sourceMappingURL=client-BGSZMMvf.js.map