@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/utils/useTranslations.js

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useMetropolis } from './useMetropolis.js';
+export const useTranslations = (options = {})=>{
+    const { locale = 'en', namespace, autoProcess = true, processInterval = 1000 } = options;
+    const { translationActions } = useMetropolis();
+    const processTimeoutRef = useRef(null);
+    const lastProcessRef = useRef(0);
+    const t = useCallback((key, fallback)=>{
+        if (!translationActions) {
+            return fallback || key;
+        }
+        const translation = translationActions.getTranslation(key, locale, namespace);
+        if (translation) {
+            return translation;
+        }
+        if (autoProcess && !translationActions.hasTranslation(key, locale, namespace)) {
+            translationActions.queueTranslationKey(key, locale, namespace);
+        }
+        return fallback || key;
+    }, [
+        translationActions,
+        locale,
+        namespace,
+        autoProcess
+    ]);
+    const hasTranslation = useCallback((key)=>{
+        if (!translationActions) {
+            return false;
+        }
+        return translationActions.hasTranslation(key, locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace
+    ]);
+    const queueTranslation = useCallback((key)=>{
+        if (!translationActions) return;
+        translationActions.queueTranslationKey(key, locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace
+    ]);
+    const processPending = useCallback(async ()=>{
+        if (!translationActions) return;
+        const now = Date.now();
+        if (now - lastProcessRef.current < processInterval) {
+            return;
+        }
+        lastProcessRef.current = now;
+        await translationActions.processPendingTranslations(locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace,
+        processInterval
+    ]);
+    useEffect(()=>{
+        if (!autoProcess || !translationActions) return;
+        const processQueued = ()=>{
+            processPending();
+        };
+        if (processTimeoutRef.current) {
+            clearTimeout(processTimeoutRef.current);
+        }
+        processTimeoutRef.current = setTimeout(processQueued, processInterval);
+        return ()=>{
+            if (processTimeoutRef.current) {
+                clearTimeout(processTimeoutRef.current);
+            }
+        };
+    }, [
+        autoProcess,
+        translationActions,
+        processPending,
+        processInterval
+    ]);
+    const isLoading = useMemo(()=>{
+        if (!translationActions) return false;
+        const state = translationActions.flux?.getState('translations');
+        return state?.isQueueing || false;
+    }, [
+        translationActions
+    ]);
+    const error = useMemo(()=>{
+        if (!translationActions) return null;
+        const state = translationActions.flux?.getState('translations');
+        return state?.error || null;
+    }, [
+        translationActions
+    ]);
+    return {
+        t,
+        hasTranslation,
+        queueTranslation,
+        processPending,
+        isLoading,
+        error
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/useTranslations.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\n\nimport { useMetropolis } from './useMetropolis.js';\n\nexport interface UseTranslationsOptions {\n  readonly locale?: string;\n  readonly namespace?: string;\n  readonly autoProcess?: boolean;\n  readonly processInterval?: number;\n}\n\nexport interface UseTranslationsReturn {\n  readonly t: (key: string, fallback?: string) => string;\n  readonly hasTranslation: (key: string) => boolean;\n  readonly queueTranslation: (key: string) => void;\n  readonly processPending: () => Promise<void>;\n  readonly isLoading: boolean;\n  readonly error: Error | null;\n}\n\nexport const useTranslations = (options: UseTranslationsOptions = {}): UseTranslationsReturn => {\n  const {\n    locale = 'en',\n    namespace,\n    autoProcess = true,\n    processInterval = 1000\n  } = options;\n\n  const {translationActions} = useMetropolis();\n  const processTimeoutRef = useRef<NodeJS.Timeout | null>(null);\n  const lastProcessRef = useRef<number>(0);\n\n  const t = useCallback((key: string, fallback?: string): string => {\n    if (!translationActions) {\n      return fallback || key;\n    }\n\n    const translation = translationActions.getTranslation(key, locale, namespace);\n\n    if (translation) {\n      return translation;\n    }\n\n    if (autoProcess && !translationActions.hasTranslation(key, locale, namespace)) {\n      translationActions.queueTranslationKey(key, locale, namespace);\n    }\n\n    return fallback || key;\n  }, [translationActions, locale, namespace, autoProcess]);\n\n  const hasTranslation = useCallback((key: string): boolean => {\n    if (!translationActions) {\n      return false;\n    }\n\n    return translationActions.hasTranslation(key, locale, namespace);\n  }, [translationActions, locale, namespace]);\n\n  const queueTranslation = useCallback((key: string): void => {\n    if (!translationActions) return;\n    translationActions.queueTranslationKey(key, locale, namespace);\n  }, [translationActions, locale, namespace]);\n\n  const processPending = useCallback(async (): Promise<void> => {\n    if (!translationActions) return;\n\n    const now = Date.now();\n    if (now - lastProcessRef.current < processInterval) {\n      return;\n    }\n\n    lastProcessRef.current = now;\n    await translationActions.processPendingTranslations(locale, namespace);\n  }, [translationActions, locale, namespace, processInterval]);\n\n  useEffect(() => {\n    if (!autoProcess || !translationActions) return;\n\n    const processQueued = () => {\n      processPending();\n    };\n\n    if (processTimeoutRef.current) {\n      clearTimeout(processTimeoutRef.current);\n    }\n\n    processTimeoutRef.current = setTimeout(processQueued, processInterval);\n\n    return () => {\n      if (processTimeoutRef.current) {\n        clearTimeout(processTimeoutRef.current);\n      }\n    };\n  }, [autoProcess, translationActions, processPending, processInterval]);\n\n  const isLoading = useMemo(() => {\n    if (!translationActions) return false;\n    const state = (translationActions as any).flux?.getState('translations');\n    return state?.isQueueing || false;\n  }, [translationActions]);\n\n  const error = useMemo(() => {\n    if (!translationActions) return null;\n    const state = (translationActions as any).flux?.getState('translations');\n    return state?.error || null;\n  }, [translationActions]);\n\n  return {\n    t,\n    hasTranslation,\n    queueTranslation,\n    processPending,\n    isLoading,\n    error\n  };\n};"],"names":["useCallback","useEffect","useMemo","useRef","useMetropolis","useTranslations","options","locale","namespace","autoProcess","processInterval","translationActions","processTimeoutRef","lastProcessRef","t","key","fallback","translation","getTranslation","hasTranslation","queueTranslationKey","queueTranslation","processPending","now","Date","current","processPendingTranslations","processQueued","clearTimeout","setTimeout","isLoading","state","flux","getState","isQueueing","error"],"mappings":"AAAA;;;CAGC,GACD,SAASA,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAQ,QAAQ;AAEhE,SAASC,aAAa,QAAQ,qBAAqB;AAkBnD,OAAO,MAAMC,kBAAkB,CAACC,UAAkC,CAAC,CAAC;IAClE,MAAM,EACJC,SAAS,IAAI,EACbC,SAAS,EACTC,cAAc,IAAI,EAClBC,kBAAkB,IAAI,EACvB,GAAGJ;IAEJ,MAAM,EAACK,kBAAkB,EAAC,GAAGP;IAC7B,MAAMQ,oBAAoBT,OAA8B;IACxD,MAAMU,iBAAiBV,OAAe;IAEtC,MAAMW,IAAId,YAAY,CAACe,KAAaC;QAClC,IAAI,CAACL,oBAAoB;YACvB,OAAOK,YAAYD;QACrB;QAEA,MAAME,cAAcN,mBAAmBO,cAAc,CAACH,KAAKR,QAAQC;QAEnE,IAAIS,aAAa;YACf,OAAOA;QACT;QAEA,IAAIR,eAAe,CAACE,mBAAmBQ,cAAc,CAACJ,KAAKR,QAAQC,YAAY;YAC7EG,mBAAmBS,mBAAmB,CAACL,KAAKR,QAAQC;QACtD;QAEA,OAAOQ,YAAYD;IACrB,GAAG;QAACJ;QAAoBJ;QAAQC;QAAWC;KAAY;IAEvD,MAAMU,iBAAiBnB,YAAY,CAACe;QAClC,IAAI,CAACJ,oBAAoB;YACvB,OAAO;QACT;QAEA,OAAOA,mBAAmBQ,cAAc,CAACJ,KAAKR,QAAQC;IACxD,GAAG;QAACG;QAAoBJ;QAAQC;KAAU;IAE1C,MAAMa,mBAAmBrB,YAAY,CAACe;QACpC,IAAI,CAACJ,oBAAoB;QACzBA,mBAAmBS,mBAAmB,CAACL,KAAKR,QAAQC;IACtD,GAAG;QAACG;QAAoBJ;QAAQC;KAAU;IAE1C,MAAMc,iBAAiBtB,YAAY;QACjC,IAAI,CAACW,oBAAoB;QAEzB,MAAMY,MAAMC,KAAKD,GAAG;QACpB,IAAIA,MAAMV,eAAeY,OAAO,GAAGf,iBAAiB;YAClD;QACF;QAEAG,eAAeY,OAAO,GAAGF;QACzB,MAAMZ,mBAAmBe,0BAA0B,CAACnB,QAAQC;IAC9D,GAAG;QAACG;QAAoBJ;QAAQC;QAAWE;KAAgB;IAE3DT,UAAU;QACR,IAAI,CAACQ,eAAe,CAACE,oBAAoB;QAEzC,MAAMgB,gBAAgB;YACpBL;QACF;QAEA,IAAIV,kBAAkBa,OAAO,EAAE;YAC7BG,aAAahB,kBAAkBa,OAAO;QACxC;QAEAb,kBAAkBa,OAAO,GAAGI,WAAWF,eAAejB;QAEtD,OAAO;YACL,IAAIE,kBAAkBa,OAAO,EAAE;gBAC7BG,aAAahB,kBAAkBa,OAAO;YACxC;QACF;IACF,GAAG;QAAChB;QAAaE;QAAoBW;QAAgBZ;KAAgB;IAErE,MAAMoB,YAAY5B,QAAQ;QACxB,IAAI,CAACS,oBAAoB,OAAO;QAChC,MAAMoB,QAAQ,AAACpB,mBAA2BqB,IAAI,EAAEC,SAAS;QACzD,OAAOF,OAAOG,cAAc;IAC9B,GAAG;QAACvB;KAAmB;IAEvB,MAAMwB,QAAQjC,QAAQ;QACpB,IAAI,CAACS,oBAAoB,OAAO;QAChC,MAAMoB,QAAQ,AAACpB,mBAA2BqB,IAAI,EAAEC,SAAS;QACzD,OAAOF,OAAOI,SAAS;IACzB,GAAG;QAACxB;KAAmB;IAEvB,OAAO;QACLG;QACAK;QACAE;QACAC;QACAQ;QACAK;IACF;AACF,EAAE"}

package/lib/utils/validatorFactory.d.ts

@@ -40,9 +40,10 @@ export declare const createValidatorFactory: <T extends BaseAdapterOptions>(defa
  * );
  */
 export declare const createValidatorManager: <T extends BaseAdapterOptions>(defaultValidator: (input: unknown, options?: T) => any, initialOptions?: T) => {
-    getCustomAdapter: () => ((input: unknown, options?: T) => any) | undefined;
+    getCustomAdapter: () => (input: unknown, options?: T) => any;
     getOptions: () => T;
     updateAdapter: (adapter: (input: unknown, options?: T) => any) => void;
     updateOptions: (options: T) => void;
-    validator: (input: unknown, validatorOptions?: T | undefined) => any;
+    validator: (input: unknown, validatorOptions?: T) => any;
 };
+//# sourceMappingURL=validatorFactory.d.ts.map

package/lib/utils/validatorFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validatorFactory.d.ts","sourceRoot":"","sources":["../../src/utils/validatorFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;IACpD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAChD;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,kBAAkB,EACjE,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EACtD,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EACpD,UAAU,CAAC,MACP,OAAO,OAAO,EAAE,mBAAmB,CAAC,QAczC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,kBAAkB,EACjE,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EAEtD,iBAAgB,CAAW;oCAMC,OAAO,YAAY,CAAC,KAAK,GAAG;;6BAExB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,KAAG,IAAI;6BAI3C,CAAC,KAAG,IAAI;uBAMd,OAAO,qBAAqB,CAAC;CAuBxD,CAAC"}

package/lib/utils/validatorFactory.js

@@ -1,2 +1,95 @@
-const p=(a,i,r)=>(n,o)=>{const t={...r,...o};let e=a(n,t);return i&&(e=i(e,t)),t?.customValidation&&(e=t.customValidation(e)),e},d=(a,i={})=>{let n={...{},...i},o,t=p(a,o,n);return{getCustomAdapter:()=>o,getOptions:()=>({...n}),updateAdapter:s=>{o=s,t=p(a,o,n)},updateOptions:s=>{n={...n,...s},t=p(a,o,n)},validator:t}};export{p as createValidatorFactory,d as createValidatorManager};
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ /**
+ * Creates a validator factory that merges custom adapters with default behavior.
+ * This eliminates code duplication across all action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param customAdapter - Optional custom adapter function
+ * @param options - Adapter options
+ * @returns A validator function that applies default + custom validation
+ *
+ * @example
+ * const validateUser = createValidatorFactory(
+ *   defaultUserValidator,
+ *   customUserAdapter,
+ *   userAdapterOptions
+ * );
+ */ export const createValidatorFactory = (defaultValidator, customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        let validated = defaultValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+/**
+ * Creates a validator manager that handles adapter updates and recreation.
+ * This centralizes the update logic that's duplicated across action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param initialOptions - Initial adapter options
+ * @returns An object with validator and update functions
+ *
+ * @example
+ * const { validator, updateAdapter, updateOptions } = createValidatorManager(
+ *   defaultUserValidator,
+ *   userAdapterOptions
+ * );
+ */ export const createValidatorManager = (defaultValidator, // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+initialOptions = {})=>{
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const defaultOptions = {};
+    let adapterOptions = {
+        ...defaultOptions,
+        ...initialOptions
+    };
+    let customAdapter;
+    const updateAdapter = (adapter)=>{
+        customAdapter = adapter;
+    };
+    const updateOptions = (options)=>{
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        adapterOptions = {
+            ...adapterOptions,
+            ...options
+        };
+    };
+    // Create validator function that always uses current customAdapter and adapterOptions
+    const validator = (input, validatorOptions)=>{
+        const mergedOptions = {
+            ...adapterOptions,
+            ...validatorOptions
+        };
+        let validated = defaultValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+    return {
+        getCustomAdapter: ()=>customAdapter,
+        getOptions: ()=>{
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const options = {
+                ...adapterOptions
+            };
+            return options;
+        },
+        updateAdapter,
+        updateOptions,
+        validator
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/metropolisjs",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "MetropolisJS is a library to connect users to Reaktor",
   "type": "module",
   "main": "lib/index.js",
@@ -8,12 +8,40 @@
   "exports": {
     ".": {
       "import": "./lib/index.js",
-      "require": "./lib/index.js"
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./stores": {
+      "import": "./lib/stores/index.js",
+      "require": "./lib/stores/index.js",
+      "types": "./lib/stores/index.d.ts"
+    },
+    "./actions": {
+      "import": "./lib/actions/index.js",
+      "require": "./lib/actions/index.js",
+      "types": "./lib/actions/index.d.ts"
+    },
+    "./adapters": {
+      "import": "./lib/adapters/index.js",
+      "require": "./lib/adapters/index.js",
+      "types": "./lib/adapters/index.d.ts"
+    },
+    "./utils": {
+      "import": "./lib/utils/index.js",
+      "require": "./lib/utils/index.js",
+      "types": "./lib/utils/index.d.ts"
+    },
+    "./config": {
+      "import": "./lib/config/index.js",
+      "require": "./lib/config/index.js",
+      "types": "./lib/config/index.d.ts"
     }
   },
   "types": "./lib/index.d.ts",
   "scripts": {
-    "build": "lex compile --remove",
+    "build": "lex compile --remove && npm run postbuild",
+    "build:dev": "NODE_ENV=development lex compile --remove",
+    "postbuild": "npx tsc-esm-fix lib",
     "clean": "lex clean",
     "dev": "lex dev --remove",
     "format": "npm run prettier && npm run lint",
@@ -46,29 +74,42 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@nlabs/rip-hunter": "3.0.0",
-    "@nlabs/utils": "2.7.5",
-    "luxon": "^3.7.1",
-    "p-debounce": "^4.0.0",
+    "@nlabs/rip-hunter": "3.1.0",
+    "@nlabs/utils": "^2.8.6",
+    "i18next": "^25.10.9",
+    "luxon": "^3.7.2",
+    "p-debounce": "^5.1.0",
+    "react-i18next": "^16.6.6",
     "sockette": "^2.0.6",
-    "zod": "^4.0.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@jest/globals": "30.0.4",
-    "@nlabs/arkhamjs": "3.31.5",
-    "@nlabs/arkhamjs-storage-browser": "^3.30.1",
-    "@nlabs/arkhamjs-utils-react": "^3.32.4",
-    "@nlabs/lex": "^1.48.7",
+    "@jest/globals": "30.3.0",
+    "@nlabs/arkhamjs": "3.31.9",
+    "@nlabs/arkhamjs-storage-browser": "^3.30.6",
+    "@nlabs/arkhamjs-utils-react": "^3.32.7",
+    "@nlabs/lex": "^1.55.2",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.0.15",
-    "@types/react": "^19.1.8",
-    "react": "^19.1.0",
-    "typescript": "^5.8.3"
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "react": "^19.2.4",
+    "typescript": "^6.0.2"
   },
   "peerDependencies": {
     "@nlabs/arkhamjs": "^3.31.1",
     "@nlabs/arkhamjs-storage-browser": "^3.30.0",
     "@nlabs/arkhamjs-utils-react": "^3.32.0",
     "react": "^19.1.0"
+  },
+  "overrides": {
+    "cross-spawn": "^7.0.6",
+    "got": "^14.6.5",
+    "http-cache-semantics": "^4.2.0",
+    "http-proxy-middleware": "^3.0.5",
+    "lodash.pick": "npm:lodash@^4.17.21",
+    "nth-check": "^2.1.1",
+    "postcss": "^8.5.6",
+    "semver-regex": "^4.0.5",
+    "tmp": "^0.2.5"
   }
 }

package/temp_signin.ts

@@ -0,0 +1,73 @@
+/**
+ * Correct usage of signIn from MetropolisJS userActions
+ * This replaces the incorrect manual GraphQL construction
+ */
+import {FluxFramework} from '@nlabs/arkhamjs';
+import {createUserActions} from './src/actions/userActions/userActions';
+
+// Create flux instance and user actions
+const flux = new FluxFramework();
+const userActions = createUserActions(flux);
+
+/**
+ * Correct signIn usage - pass user object with authentication fields
+ */
+const signInUser = async (username: string, password: string, expires: number = 15) => {
+  try {
+    // Correct way: pass user object with username/password
+    const session = await userActions.signIn({
+      username,
+      password
+    }, expires);
+
+    console.log('Sign in successful:', session);
+    return {success: true, session};
+  } catch (error: any) {
+    console.error('Sign in failed:', error.message);
+    return {success: false, error: error.message};
+  }
+};
+
+/**
+ * Alternative: sign in with email
+ */
+const signInWithEmail = async (email: string, password: string, expires: number = 15) => {
+  try {
+    const session = await userActions.signIn({
+      email,
+      password
+    }, expires);
+
+    console.log('Sign in successful:', session);
+    return {success: true, session};
+  } catch (error: any) {
+    console.error('Sign in failed:', error.message);
+    return {success: false, error: error.message};
+  }
+};
+
+/**
+ * Alternative: sign in with phone
+ */
+const signInWithPhone = async (phone: string, password: string, expires: number = 15) => {
+  try {
+    const session = await userActions.signIn({
+      phone,
+      password
+    }, expires);
+
+    console.log('Sign in successful:', session);
+    return {success: true, session};
+  } catch (error: any) {
+    console.error('Sign in failed:', error.message);
+    return {success: false, error: error.message};
+  }
+};
+
+// Export the correct functions
+export {
+  signInUser,
+  signInWithEmail,
+  signInWithPhone
+};
+

package/lib/actions/profileActions/profileActions.d.ts

@@ -1,50 +0,0 @@
-import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { ProfileType } from '../../adapters/profileAdapter/profileAdapter';
-export interface ProfileAdapterOptions {
-    readonly strict?: boolean;
-    readonly allowPartial?: boolean;
-    readonly environment?: 'development' | 'production' | 'test';
-    readonly customValidation?: (input: unknown) => unknown;
-}
-export interface ProfileActionsOptions {
-    readonly profileAdapter?: (input: unknown, options?: ProfileAdapterOptions) => any;
-    readonly profileAdapterOptions?: ProfileAdapterOptions;
-}
-export interface ProfileApiResultsType {
-    readonly profiles: {
-        readonly addProfile?: ProfileType;
-        readonly deleteProfile?: ProfileType;
-        readonly getProfile?: ProfileType;
-        readonly getProfiles?: ProfileType[];
-        readonly updateProfile?: ProfileType;
-    };
-}
-export interface ProfileActions {
-    readonly addProfile: (profileData: Partial<ProfileType>, profileProps?: string[]) => Promise<ProfileType>;
-    readonly getProfile: (profileId: string, profileProps?: string[]) => Promise<ProfileType>;
-    readonly getProfiles: (profileIds: string[], profileProps?: string[]) => Promise<ProfileType[]>;
-    readonly deleteProfile: (profileId: string, profileProps?: string[]) => Promise<ProfileType>;
-    readonly updateProfile: (profile: Partial<ProfileType>, profileProps?: string[]) => Promise<ProfileType>;
-    readonly updateProfileAdapter: (adapter: (input: unknown, options?: ProfileAdapterOptions) => any) => void;
-    readonly updateProfileAdapterOptions: (options: ProfileAdapterOptions) => void;
-}
-/**
- * Factory function to create ProfileActions with enhanced adapter injection capabilities.
- * Custom adapters are merged with default behavior, allowing partial overrides.
- *
- * @example
- * // Basic usage with default adapters
- * const profileActions = createProfileActions(flux);
- *
- * @example
- * // Custom adapter that extends default behavior
- * const customProfileAdapter = (input: unknown, options?: ProfileAdapterOptions) => {
- *   // input is already validated by default adapter
- *   return input;
- * };
- *
- * const profileActions = createProfileActions(flux, {
- *   profileAdapter: customProfileAdapter
- * });
- */
-export declare const createProfileActions: (flux: FluxFramework, options?: ProfileActionsOptions) => ProfileActions;

package/lib/actions/profileActions/profileActions.js

@@ -1,2 +0,0 @@
-import{parseId as P}from"@nlabs/utils";import{validateProfileInput as u}from"../../adapters/profileAdapter/profileAdapter";import{PROFILE_CONSTANTS as o}from"../../stores/profileStore";import{appMutation as y,appQuery as c}from"../../utils/api";import{createBaseActions as T}from"../../utils/baseActionFactory";const f="profiles",m=(r,n)=>u(r),C=(r,n)=>{const d=T(r,m,{...n?.profileAdapter&&{adapter:n.profileAdapter},...n?.profileAdapterOptions&&{adapterOptions:n.profileAdapterOptions}});return{addProfile:async(i,t=[])=>{try{const e={profile:{type:"ProfileInput!",value:d.validator(i)}},p=l=>{const{profiles:{addProfile:s={}}}=l;return r.dispatch({profile:s,type:o.ADD_ITEM_SUCCESS})},{addProfile:a}=await y(r,"addProfile",f,e,["profileId",...t],{onSuccess:p});return a}catch(e){throw r.dispatch({error:e,type:o.ADD_ITEM_ERROR}),e}},getProfile:async(i,t=[])=>{try{const e={profileId:{type:"ID!",value:P(i)}},p=l=>{const{profiles:{getProfile:s={}}}=l;return r.dispatch({profile:s,type:o.GET_ITEM_SUCCESS})},{profile:a}=await c(r,"profile",f,e,["active","gender","hasLike","hasView","images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }","imageCount","likeCount","name","profileId","tags {name, tagId}","userId","viewCount",...t],{onSuccess:p});return a}catch(e){throw r.dispatch({error:e,type:o.GET_ITEM_ERROR}),e}},getProfiles:async(i,t=[])=>{try{const e={profileIds:{type:"[ID!]!",value:i.map(P)}},p=l=>{const{profiles:{getProfiles:s=[]}}=l;return r.dispatch({profiles:s,type:o.GET_LIST_SUCCESS})},{profiles:a}=await c(r,"profiles",f,e,["active","gender","hasLike","hasView","images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }","imageCount","likeCount","name","profileId","tags {name, tagId}","userId","viewCount",...t],{onSuccess:p});return a}catch(e){throw r.dispatch({error:e,type:o.GET_LIST_ERROR}),e}},deleteProfile:async(i,t=[])=>{try{const e={profileId:{type:"ID!",value:P(i)}},p=l=>{const{profiles:{deleteProfile:s={}}}=l;return r.dispatch({profile:s,type:o.DELETE_ITEM_SUCCESS})},{deleteProfile:a}=await y(r,"deleteProfile",f,e,["profileId",...t],{onSuccess:p});return a}catch(e){throw r.dispatch({error:e,type:o.DELETE_ITEM_ERROR}),e}},updateProfile:async(i,t=[])=>{try{const e={profile:{type:"ProfileInput!",value:d.validator(i)}},p=l=>{const{profiles:{updateProfile:s={}}}=l;return r.dispatch({profile:s,type:o.UPDATE_ITEM_SUCCESS})},{updateProfile:a}=await y(r,"updateProfile",f,e,["profileId",...t],{onSuccess:p});return a}catch(e){throw r.dispatch({error:e,type:o.UPDATE_ITEM_ERROR}),e}},updateProfileAdapter:d.updateAdapter,updateProfileAdapterOptions:d.updateOptions}};export{C as createProfileActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/profileActions/profileActions.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2023-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { parseId } from '@nlabs/utils';\n\nimport { validateProfileInput } from '../../adapters/profileAdapter/profileAdapter';\nimport { PROFILE_CONSTANTS } from '../../stores/profileStore';\nimport { appMutation, appQuery } from '../../utils/api';\nimport { createBaseActions } from '../../utils/baseActionFactory';\n\nimport type { FluxFramework } from '@nlabs/arkhamjs';\nimport type { ProfileType } from '../../adapters/profileAdapter/profileAdapter';\n\n// Define the collection name for profiles\nconst DATA_TYPE = 'profiles';\n\nexport interface ProfileAdapterOptions {\n  readonly strict?: boolean;\n  readonly allowPartial?: boolean;\n  readonly environment?: 'development' | 'production' | 'test';\n  readonly customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ProfileActionsOptions {\n  readonly profileAdapter?: (input: unknown, options?: ProfileAdapterOptions) => any;\n  readonly profileAdapterOptions?: ProfileAdapterOptions;\n}\n\nexport interface ProfileApiResultsType {\n  readonly profiles: {\n    readonly addProfile?: ProfileType;\n    readonly deleteProfile?: ProfileType;\n    readonly getProfile?: ProfileType;\n    readonly getProfiles?: ProfileType[];\n    readonly updateProfile?: ProfileType;\n  };\n}\n\nexport interface ProfileActions {\n  readonly addProfile: (profileData: Partial<ProfileType>, profileProps?: string[]) => Promise<ProfileType>;\n  readonly getProfile: (profileId: string, profileProps?: string[]) => Promise<ProfileType>;\n  readonly getProfiles: (profileIds: string[], profileProps?: string[]) => Promise<ProfileType[]>;\n  readonly deleteProfile: (profileId: string, profileProps?: string[]) => Promise<ProfileType>;\n  readonly updateProfile: (profile: Partial<ProfileType>, profileProps?: string[]) => Promise<ProfileType>;\n  readonly updateProfileAdapter: (adapter: (input: unknown, options?: ProfileAdapterOptions) => any) => void;\n  readonly updateProfileAdapterOptions: (options: ProfileAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultProfileValidator = (input: unknown, options?: ProfileAdapterOptions) => validateProfileInput(input);\n\n/**\n * Factory function to create ProfileActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const profileActions = createProfileActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customProfileAdapter = (input: unknown, options?: ProfileAdapterOptions) => {\n *   // input is already validated by default adapter\n *   return input;\n * };\n *\n * const profileActions = createProfileActions(flux, {\n *   profileAdapter: customProfileAdapter\n * });\n */\nexport const createProfileActions = (\n  flux: FluxFramework,\n  options?: ProfileActionsOptions\n): ProfileActions => {\n  const profileBase = createBaseActions(flux, defaultProfileValidator, {\n    ...(options?.profileAdapter && {adapter: options.profileAdapter}),\n    ...(options?.profileAdapterOptions && {adapterOptions: options.profileAdapterOptions})\n  });\n\n  // Action implementations\n  const addProfile = async (profileData: Partial<ProfileType>, profileProps: string[] = []): Promise<ProfileType> => {\n    try {\n      const queryVariables = {\n        profile: {\n          type: 'ProfileInput!',\n          value: profileBase.validator(profileData)\n        }\n      };\n\n      const onSuccess = (data: ProfileApiResultsType) => {\n        const {profiles: {addProfile = {}}} = data;\n        return flux.dispatch({profile: addProfile, type: PROFILE_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {addProfile} = await appMutation(flux, 'addProfile', DATA_TYPE, queryVariables, ['profileId', ...profileProps], {onSuccess});\n      return addProfile as ProfileType;\n    } catch(error) {\n      flux.dispatch({error, type: PROFILE_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getProfile = async (profileId: string, profileProps: string[] = []): Promise<ProfileType> => {\n    try {\n      const queryVariables = {\n        profileId: {\n          type: 'ID!',\n          value: parseId(profileId)\n        }\n      };\n\n      const onSuccess = (data: ProfileApiResultsType) => {\n        const {profiles: {getProfile: profile = {}}} = data;\n        return flux.dispatch({profile, type: PROFILE_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const {profile} = await appQuery(\n        flux,\n        'profile',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'active',\n          'gender',\n          'hasLike',\n          'hasView',\n          'images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }',\n          'imageCount',\n          'likeCount',\n          'name',\n          'profileId',\n          'tags {name, tagId}',\n          'userId',\n          'viewCount',\n          ...profileProps\n        ],\n        {onSuccess}\n      );\n      return profile as ProfileType;\n    } catch(error) {\n      flux.dispatch({error, type: PROFILE_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getProfiles = async (profileIds: string[], profileProps: string[] = []): Promise<ProfileType[]> => {\n    try {\n      const queryVariables = {\n        profileIds: {\n          type: '[ID!]!',\n          value: profileIds.map(parseId)\n        }\n      };\n\n      const onSuccess = (data: ProfileApiResultsType) => {\n        const {profiles: {getProfiles: profiles = []}} = data;\n        return flux.dispatch({profiles, type: PROFILE_CONSTANTS.GET_LIST_SUCCESS});\n      };\n\n      const {profiles} = await appQuery(\n        flux,\n        'profiles',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'active',\n          'gender',\n          'hasLike',\n          'hasView',\n          'images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }',\n          'imageCount',\n          'likeCount',\n          'name',\n          'profileId',\n          'tags {name, tagId}',\n          'userId',\n          'viewCount',\n          ...profileProps\n        ],\n        {onSuccess}\n      );\n      return profiles as ProfileType[];\n    } catch(error) {\n      flux.dispatch({error, type: PROFILE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteProfile = async (profileId: string, profileProps: string[] = []): Promise<ProfileType> => {\n    try {\n      const queryVariables = {\n        profileId: {\n          type: 'ID!',\n          value: parseId(profileId)\n        }\n      };\n\n      const onSuccess = (data: ProfileApiResultsType) => {\n        const {profiles: {deleteProfile: profile = {}}} = data;\n        return flux.dispatch({profile, type: PROFILE_CONSTANTS.DELETE_ITEM_SUCCESS});\n      };\n\n      const {deleteProfile} = await appMutation(flux, 'deleteProfile', DATA_TYPE, queryVariables, ['profileId', ...profileProps], {onSuccess});\n      return deleteProfile as ProfileType;\n    } catch(error) {\n      flux.dispatch({error, type: PROFILE_CONSTANTS.DELETE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const updateProfile = async (profile: Partial<ProfileType>, profileProps: string[] = []): Promise<ProfileType> => {\n    try {\n      const queryVariables = {\n        profile: {\n          type: 'ProfileInput!',\n          value: profileBase.validator(profile)\n        }\n      };\n\n      const onSuccess = (data: ProfileApiResultsType) => {\n        const {profiles: {updateProfile: profile = {}}} = data;\n        return flux.dispatch({profile, type: PROFILE_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const {updateProfile} = await appMutation(flux, 'updateProfile', DATA_TYPE, queryVariables, ['profileId', ...profileProps], {onSuccess});\n      return updateProfile as ProfileType;\n    } catch(error) {\n      flux.dispatch({error, type: PROFILE_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  return {\n    addProfile,\n    getProfile,\n    getProfiles,\n    deleteProfile,\n    updateProfile,\n    updateProfileAdapter: profileBase.updateAdapter,\n    updateProfileAdapterOptions: profileBase.updateOptions\n  };\n};"],
  "mappings": "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",
  "names": ["parseId", "validateProfileInput", "PROFILE_CONSTANTS", "appMutation", "appQuery", "createBaseActions", "DATA_TYPE", "defaultProfileValidator", "input", "options", "createProfileActions", "flux", "profileBase", "profileData", "profileProps", "queryVariables", "onSuccess", "data", "addProfile", "error", "profileId", "profile", "profileIds", "profiles", "deleteProfile", "updateProfile"]
}


package/lib/adapters/profileAdapter/profileAdapter.d.ts

@@ -1,32 +0,0 @@
-export interface ProfileType {
-    _id?: string;
-    _key?: string;
-    _rev?: string;
-    _oldRev?: string;
-    _from?: string;
-    _to?: string;
-    active?: boolean;
-    gender?: string;
-    hasLike?: boolean;
-    hasView?: boolean;
-    id?: string;
-    images?: any[];
-    imageCount?: number;
-    imageId?: string;
-    imageUrl?: string;
-    likeCount?: number;
-    name?: string;
-    profileId?: string;
-    tags?: any[];
-    thumbUrl?: string;
-    userId?: string;
-    viewCount?: number;
-    [key: string]: any;
-}
-export declare class ProfileValidationError extends Error {
-    field?: string | undefined;
-    constructor(message: string, field?: string | undefined);
-}
-export declare const validateProfileInput: (profile: unknown) => ProfileType;
-export declare const formatProfileOutput: (profile: ProfileType) => ProfileType;
-export declare const parseProfile: (profile: ProfileType) => ProfileType;

package/lib/adapters/profileAdapter/profileAdapter.js

@@ -1,2 +0,0 @@
-import{parseArangoId as C,parseBoolean as s,parseChar as T,parseId as l,parseNum as p,parseString as x}from"@nlabs/utils";import{z as e}from"zod";import{parseDocument as E,removeEmptyKeys as U}from"../arangoAdapter/arangoAdapter";import{parseImage as V}from"../imageAdapter/imageAdapter";import{parseTag as $}from"../tagAdapter/tagAdapter";class g extends Error{constructor(i,n){super(i);this.field=n;this.name="ProfileValidationError"}}const L=e.object({_id:e.string().optional(),_key:e.string().optional(),_rev:e.string().optional(),_oldRev:e.string().optional(),_from:e.string().optional(),_to:e.string().optional(),active:e.boolean().optional(),gender:e.string().max(1).optional(),hasLike:e.boolean().optional(),hasView:e.boolean().optional(),id:e.string().optional(),images:e.array(e.any()).optional(),imageCount:e.number().optional(),imageId:e.string().optional(),imageUrl:e.string().optional(),likeCount:e.number().optional(),name:e.string().max(64).optional(),profileId:e.string().optional(),tags:e.array(e.any()).optional(),thumbUrl:e.string().optional(),userId:e.string().optional(),viewCount:e.number().optional()}).passthrough(),K=o=>{try{return L.parse(o)}catch(r){if(r instanceof e.ZodError){const i=r.issues.map(n=>`${n.path.join(".")}: ${n.message}`).join(", ");throw new g(`Profile validation failed: ${i}`)}throw r}},N=o=>o,O=o=>{try{return j(o)}catch(r){throw r instanceof g?r:new g(`Profile parsing failed: ${r instanceof Error?r.message:"Unknown error"}`)}},j=o=>{const{_id:r,_key:i,active:n,gender:m,hasLike:d,hasView:f,id:u,images:c,imageCount:h,imageId:y,imageUrl:P,likeCount:b,name:v,profileId:t,tags:I,thumbUrl:w,userId:k,viewCount:_}=o;return U({...E(o),...n!==void 0&&{active:s(n)},...m&&{gender:T(m,1)},...d!==void 0&&{hasLike:s(d)},...f!==void 0&&{hasView:s(f)},...(r||u||i||t)&&{id:C(r||u||`profiles/${i||t}`)},...c?.length&&{images:c.map(a=>V(a))},...h!==void 0&&{imageCount:p(h)},...y&&{imageId:l(y)},...P&&{imageUrl:P},...b!==void 0&&{likeCount:p(b)},...v&&{name:x(v,64)},...(i||t)&&{profileId:l(i||t||"")},...I?.length&&{tags:I.map(a=>$(a))},...w&&{thumbUrl:w},...k&&{userId:l(k)},..._!==void 0&&{viewCount:p(_)}})};export{g as ProfileValidationError,N as formatProfileOutput,O as parseProfile,K as validateProfileInput};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/adapters/profileAdapter/profileAdapter.ts"],
  "sourcesContent": ["import {parseArangoId, parseBoolean, parseChar, parseId, parseNum, parseString} from '@nlabs/utils';\nimport {z} from 'zod';\n\nimport {parseDocument, removeEmptyKeys} from '../arangoAdapter/arangoAdapter';\nimport {parseImage} from '../imageAdapter/imageAdapter';\nimport {parseTag} from '../tagAdapter/tagAdapter';\n\nexport interface ProfileType {\n  _id?: string;\n  _key?: string;\n  _rev?: string;\n  _oldRev?: string;\n  _from?: string;\n  _to?: string;\n  active?: boolean;\n  gender?: string;\n  hasLike?: boolean;\n  hasView?: boolean;\n  id?: string;\n  images?: any[];\n  imageCount?: number;\n  imageId?: string;\n  imageUrl?: string;\n  likeCount?: number;\n  name?: string;\n  profileId?: string;\n  tags?: any[];\n  thumbUrl?: string;\n  userId?: string;\n  viewCount?: number;\n  [key: string]: any;\n}\n\nexport class ProfileValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'ProfileValidationError';\n  }\n}\n\nconst ProfileInputSchema = z.object({\n  _id: z.string().optional(),\n  _key: z.string().optional(),\n  _rev: z.string().optional(),\n  _oldRev: z.string().optional(),\n  _from: z.string().optional(),\n  _to: z.string().optional(),\n  active: z.boolean().optional(),\n  gender: z.string().max(1).optional(),\n  hasLike: z.boolean().optional(),\n  hasView: z.boolean().optional(),\n  id: z.string().optional(),\n  images: z.array(z.any()).optional(),\n  imageCount: z.number().optional(),\n  imageId: z.string().optional(),\n  imageUrl: z.string().optional(),\n  likeCount: z.number().optional(),\n  name: z.string().max(64).optional(),\n  profileId: z.string().optional(),\n  tags: z.array(z.any()).optional(),\n  thumbUrl: z.string().optional(),\n  userId: z.string().optional(),\n  viewCount: z.number().optional()\n}).passthrough();\n\nexport const validateProfileInput = (profile: unknown): ProfileType => {\n  try {\n    const validated = ProfileInputSchema.parse(profile);\n    return validated as ProfileType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const fieldErrors = error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');\n      throw new ProfileValidationError(`Profile validation failed: ${fieldErrors}`);\n    }\n    throw error;\n  }\n};\n\nexport const formatProfileOutput = (profile: ProfileType): ProfileType => profile;\n\nexport const parseProfile = (profile: ProfileType): ProfileType => {\n  try {\n    const parsed = performProfileTransformation(profile);\n    return parsed;\n  } catch(error) {\n    if(error instanceof ProfileValidationError) {\n      throw error;\n    }\n    throw new ProfileValidationError(`Profile parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n  }\n};\n\nconst performProfileTransformation = (profile: ProfileType): ProfileType => {\n  const {\n    _id,\n    _key,\n    active,\n    gender,\n    hasLike,\n    hasView,\n    id,\n    images,\n    imageCount,\n    imageId,\n    imageUrl,\n    likeCount,\n    name,\n    profileId,\n    tags,\n    thumbUrl,\n    userId,\n    viewCount\n  } = profile;\n\n  const transformed = removeEmptyKeys({\n    ...parseDocument(profile),\n    ...(active !== undefined && {active: parseBoolean(active)}),\n    ...(gender && {gender: parseChar(gender, 1)}),\n    ...(hasLike !== undefined && {hasLike: parseBoolean(hasLike)}),\n    ...(hasView !== undefined && {hasView: parseBoolean(hasView)}),\n    ...((_id || id || _key || profileId) && {id: parseArangoId(_id || id || `profiles/${_key || profileId}`)}),\n    ...(images?.length && {images: images.map((image) => parseImage(image))}),\n    ...(imageCount !== undefined && {imageCount: parseNum(imageCount)}),\n    ...(imageId && {imageId: parseId(imageId)}),\n    ...(imageUrl && {imageUrl}),\n    ...(likeCount !== undefined && {likeCount: parseNum(likeCount)}),\n    ...(name && {name: parseString(name, 64)}),\n    ...((_key || profileId) && {profileId: parseId(_key || profileId || '')}),\n    ...(tags?.length && {tags: tags.map((tag) => parseTag(tag))}),\n    ...(thumbUrl && {thumbUrl}),\n    ...(userId && {userId: parseId(userId)}),\n    ...(viewCount !== undefined && {viewCount: parseNum(viewCount)})\n  });\n\n  return transformed as ProfileType;\n};"],
  "mappings": "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",
  "names": ["parseArangoId", "parseBoolean", "parseChar", "parseId", "parseNum", "parseString", "z", "parseDocument", "removeEmptyKeys", "parseImage", "parseTag", "ProfileValidationError", "message", "field", "ProfileInputSchema", "validateProfileInput", "profile", "error", "fieldErrors", "e", "formatProfileOutput", "parseProfile", "performProfileTransformation", "_id", "_key", "active", "gender", "hasLike", "hasView", "id", "images", "imageCount", "imageId", "imageUrl", "likeCount", "name", "profileId", "tags", "thumbUrl", "userId", "viewCount", "image", "tag"]
}


package/lib/stores/profileStore.d.ts

@@ -1,24 +0,0 @@
-import type { ProfileType } from '../adapters/profileAdapter/profileAdapter';
-export declare const PROFILE_CONSTANTS: {
-    ADD_ITEM_ERROR: string;
-    ADD_ITEM_SUCCESS: string;
-    DELETE_ITEM_ERROR: string;
-    DELETE_ITEM_SUCCESS: string;
-    GET_ITEM_ERROR: string;
-    GET_ITEM_SUCCESS: string;
-    GET_LIST_ERROR: string;
-    GET_LIST_SUCCESS: string;
-    UPDATE_ITEM_ERROR: string;
-    UPDATE_ITEM_SUCCESS: string;
-};
-export interface ProfileState {
-    readonly error?: Error;
-    readonly list: ProfileType[];
-    readonly listMap: Record<string, ProfileType>;
-}
-export declare const initialProfileState: ProfileState;
-export declare const profileStore: {
-    initialState: ProfileState;
-    name: string;
-    reducer: (state?: ProfileState, action?: {}, _next?: {}) => ProfileState;
-};