TypeScript constate.default函数代码示例

        error,
      } = subscriptionData;

      if (error) {
        errorNotification('Error', ERRORS.SERVER);
        return;
      }

      switch (type) {
        case SubscriptionType.ADD: {
          onAdd(addonsConfiguration);
          break;
        }
        case SubscriptionType.UPDATE: {
          onUpdate(addonsConfiguration);
          break;
        }
        case SubscriptionType.DELETE: {
          onDelete(addonsConfiguration);
          break;
        }
        default:
          break;
      }
    },
  });
};

const { Provider, Context } = createContainer(useSubscriptions);
export { Provider as SubscriptionsProvider, Context as SubscriptionsService };

  const getUrlsFromConfigByName = (configName: string): string[] => {
    const config = originalConfigs.find(c => c.name === configName);
    return config ? config.urls : [];
  };

  const validateUrl = (url: string, existingUrls: string[]): string => {
    if (existingUrls.includes(url)) {
      return URL_ERRORS.ALREADY_EXISTS;
    }
    if (HELM_BROKER_IS_DEVELOPMENT_MODE) {
      if (!(url.startsWith('https://') || url.startsWith('http://'))) {
        return URL_ERRORS.STARTS_WITH_HTTP.DEVELOPMENT_MODE;
      }
    } else {
      if (!url.startsWith('https://')) {
        return URL_ERRORS.STARTS_WITH_HTTP.NOT_DEVELOPMENT_MODE;
      }
    }
    return '';
  };

  return {
    getUrlsFromConfigByName,
    validateUrl,
  };
};

const { Provider, Context } = createContainer(useUrls);
export { Provider as UrlsProvider, Context as UrlsService };

      type: ActiveFiltersActionType.REMOVE_LABEL,
      payload: { key, value },
    });
  };

  const removeAllFiltersLabels = () => {
    dispatchActiveFilters({
      type: ActiveFiltersActionType.REMOVE_ALL_FILTERS,
      payload: { key: '', value: '' },
    });
  };

  const hasActiveLabel = (key: string, value: string): boolean => {
    return (
      activeFilters.labels[key] && activeFilters.labels[key].includes(value)
    );
  };

  return {
    activeFilters,
    setSearchFilter,
    setFilterLabel,
    removeFilterLabel,
    removeAllFiltersLabels,
    hasActiveLabel,
  };
};

const { Provider, Context } = createContainer(useFilters);
export { Provider as FiltersProvider, Context as FiltersService };

      title,
      content,
      color: '#359c46',
      icon: 'accept',
    });
  };

  const errorNotification = (
    title: string,
    content: string | React.ReactNode,
  ) => {
    setNotification({
      title,
      content,
      color: '#359c46',
      icon: 'accept',
    });
  };

  return {
    notification,
    showNotification,
    hideNotification,
    successNotification,
    errorNotification,
  };
};

const { Provider, Context } = createContainer(useNotifications);
export { Provider as NotificationsProvider, Context as NotificationsService };

        for (const activeFilterKey in activeFilters.labels) {
          if (
            activeFilters.labels[activeFilterKey].includes(
              config.labels[labelKey],
            )
          ) {
            return true;
          }
        }
      }
      return false;
    });

    const sortedConfigs = sortConfigByName(filterBySearch(newFilteredConfigs));
    setFilteredConfigs(sortedConfigs);
  }, [originalConfigs, activeFilters]);

  return {
    originalConfigs,
    setOriginalConfigs,
    validateName,
    configNameGenerator,
    configurationNames,
    filteredConfigs,
    configurationsExist,
  };
};

const { Provider, Context } = createContainer(useConfigurations);
export { Provider as ConfigurationsProvider, Context as ConfigurationsService };

    CreateAddonsConfigurationVariables
  >(CREATE_ADDONS_CONFIGURATION_MUTATION);
  const updateAddonsConfiguration = useMutation<
    {},
    UpdateAddonsConfigurationVariables
  >(UPDATE_ADDONS_CONFIGURATION_MUTATION);
  const deleteAddonsConfiguration = useMutation<
    {},
    DeleteAddonsConfigurationVariables
  >(DELETE_ADDONS_CONFIGURATION_MUTATION);
  const addAddonsConfigurationUrls = useMutation<
    {},
    AddAddonsConfigurationUrlsVariables
  >(ADD_ADDONS_CONFIGURATION_URLS_MUTATION);
  const removeAddonsConfigurationUrls = useMutation<
    {},
    RemoveAddonsConfigurationUrlsVariables
  >(REMOVE_ADDONS_CONFIGURATION_URLS_MUTATION);

  return {
    createAddonsConfiguration,
    updateAddonsConfiguration,
    deleteAddonsConfiguration,
    addAddonsConfigurationUrls,
    removeAddonsConfigurationUrls,
  };
};

const { Provider, Context } = createContainer(useMutations);
export { Provider as MutationsProvider, Context as MutationsService };

import gql from 'graphql-tag';
import createContainer from 'constate';
import { useQuery } from 'react-apollo-hooks';

export const ADDONS_CONFIGURATIONS_QUERY = gql`
  query addonsConfigurations {
    addonsConfigurations {
      name
      urls
      labels
    }
  }
`;

const useQueries = () => {
  const { data, error, loading } = useQuery(ADDONS_CONFIGURATIONS_QUERY);

  return {
    addonsConfigurations: data.addonsConfigurations,
    error,
    loading,
  };
};

const { Provider, Context } = createContainer(useQueries);
export { Provider as QueriesProvider, Context as QueriesService };