# extendify/0.2.0/src/state/User.js

Extendify, version 0.2.0. 103 lines.

- Page: https://pluginprobe.com/plugins/extendify/0.2.0/code/src/state/User.js
- Raw: https://pluginprobe.com/plugins/extendify/0.2.0/raw/src/state/User.js
- Modified: 2022-01-13T17:04:32+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/extendify/0.2.0/code/src/state/User.js#L10-L20`.

```javascript
import create from 'zustand'
import { persist } from 'zustand/middleware'
import { User } from '../api/User'

const storage = {
    getItem: async () => await User.getData(),
    setItem: async (_name, value) => await User.setData(value),
    removeItem: () => {},
}

const isGlobalLibraryEnabled = () =>
    window.extendifyData.sitesettings === null ||
    window.extendifyData?.sitesettings?.state?.enabled

export const useUserStore = create(
    persist(
        (set, get) => ({
            firstLoadedOn: new Date().toISOString(),
            email: '',
            apiKey: '',
            imports: 0,
            uuid: '',
            sdkPartner: '',
            registration: {
                email: '',
                optedOut: false,
            },
            noticesDismissedAt: {},
            allowedImports: 0,
            entryPoint: 'not-set',
            enabled: isGlobalLibraryEnabled(),
            canInstallPlugins: false,
            canActivatePlugins: false,
            preferredOptions: {
                taxonomies: {},
                type: '',
                search: '',
            },
            preferredOptionsHistory: {
                siteType: [],
            },
            incrementImports: () => set({ imports: get().imports + 1 }),
            hasAvailableImports: () =>
                get().apiKey
                    ? true
                    : Number(get().imports) < Number(get().allowedImports),
            remainingImports: () => {
                if (get().apiKey) {
                    return 'unlimited'
                }
                const remaining =
                    Number(get().allowedImports) - Number(get().imports)
                return remaining > 0 ? remaining : 0
            },
            updatePreferredSiteType: (value) => {
                get().updatePreferredOption('siteType', value)
                if (!value?.slug || value.slug === 'unknown') return
                const current = get().preferredOptionsHistory?.siteType ?? []

                // If the site type isn't already included, prepend it
                if (!current.find((t) => t.slug === value.slug)) {
                    const siteType = [value, ...current]
                    set({
                        preferredOptionsHistory: Object.assign(
                            {},
                            get().preferredOptionsHistory,
                            { siteType: siteType.slice(0, 3) },
                        ),
                    })
                }
            },
            updatePreferredOption: (option, value) => {
                // If the option doesn't exist, assume it's a taxonomy
                if (
                    !Object.prototype.hasOwnProperty.call(
                        get().preferredOptions,
                        option,
                    )
                ) {
                    value = Object.assign(
                        {},
                        get().preferredOptions?.taxonomies ?? {},
                        { [option]: value },
                    )
                    option = 'taxonomies'
                }

                set({
                    preferredOptions: {
                        ...Object.assign({}, get().preferredOptions, {
                            [option]: value,
                        }),
                    },
                })
            },
        }),
        {
            name: 'extendify-user',
            getStorage: () => storage,
        },
    ),
)

```