@daffodil/category 0.42.1 → 0.43.0

package/fesm2020/daffodil-category.mjs

@@ -1,22 +1,6 @@
-import { DaffInheritableError, daffArrayToDict } from '@daffodil/core';
 import { InjectionToken } from '@angular/core';
 import { daffTransformErrorToStateError } from '@daffodil/core/state';
 
-/**
- * The known types of filters.
- */
-var DaffCategoryFilterType;
-(function (DaffCategoryFilterType) {
-    DaffCategoryFilterType["Equal"] = "equal";
-    DaffCategoryFilterType["RangeNumeric"] = "rangeNumeric";
-})(DaffCategoryFilterType || (DaffCategoryFilterType = {}));
-
-/**
- * The separator between a range type filter's values
- * e.g. "price": "30-40".
- */
-const DaffCategoryFromToFilterSeparator = '-';
-
 /**
  * When you request a category page, there's two ways to do so, via URL or via ID.
  */
@@ -28,563 +12,15 @@ var DaffCategoryRequestKind;
 })(DaffCategoryRequestKind || (DaffCategoryRequestKind = {}));
 ;
 
-/**
- * The error codes applicable to the filter behaviors of `@daffodil/category`.
- *
- * @docs-private
- */
-var DaffCategoryFilterErrorCodes;
-(function (DaffCategoryFilterErrorCodes) {
-    DaffCategoryFilterErrorCodes["FILTER_REQUEST_TYPE_MISMATCH"] = "DAFF_CATEGORY_FILTER_REQUEST_TYPE_MISMATCH";
-    DaffCategoryFilterErrorCodes["FILTER_REQUEST_NAME_MISMATCH"] = "DAFF_CATEGORY_FILTER_REQUEST_NAME_MISMATCH";
-    DaffCategoryFilterErrorCodes["FILTER_NOT_FOUND"] = "DAFF_CATEGORY_FILTER_NOT_FOUND";
-    DaffCategoryFilterErrorCodes["UNKNOWN_FILTER_TYPE"] = "DAFF_CATEGORY_UNKNOWN_FILTER_TYPE";
-})(DaffCategoryFilterErrorCodes || (DaffCategoryFilterErrorCodes = {}));
-
-/**
- *
- * The available error codes of the @daffodil/category package.
- *
- * Note that this only contains errors in the root @daffodil/category package, not
- * any of its subpackages e.g. `@daffodil/category/testing`.
- */
-const DaffCategoryErrorCodes = {
-    ...DaffCategoryFilterErrorCodes,
-};
-
-/**
- * An error thrown when a lookup for a filter.
- */
-class DaffCategoryFilterNotFound extends DaffInheritableError {
-    constructor(message) {
-        super(message);
-        this.code = DaffCategoryErrorCodes.FILTER_NOT_FOUND;
-    }
-}
-
-/**
- * An error thrown when an operation targeting a filter matching one name
- * matches a filter of another name.
- */
-class DaffCategoryFilterRequestNameMismatch extends DaffInheritableError {
-    constructor(message) {
-        super(message);
-        this.code = DaffCategoryErrorCodes.FILTER_REQUEST_NAME_MISMATCH;
-    }
-}
-
-/**
- * An error thrown when an operation targeting a filter matching one type
- * matches a filter of another type.
- */
-class DaffCategoryFilterRequestTypeMismatch extends DaffInheritableError {
-    constructor(message) {
-        super(message);
-        this.code = DaffCategoryErrorCodes.FILTER_REQUEST_TYPE_MISMATCH;
-    }
-}
-
-/**
- * An error thrown when an operation targeting a filter matches a type unknown
- * to Daffodil.
- */
-class DaffCategoryUnknownFilterType extends DaffInheritableError {
-    constructor(message) {
-        super(message);
-        this.code = DaffCategoryErrorCodes.UNKNOWN_FILTER_TYPE;
-    }
-}
-
-/**
- * A mapping from error codes to error class constructors.
- */
-const DaffCategoryFiltersErrorMap = {
-    [DaffCategoryFilterErrorCodes.FILTER_REQUEST_TYPE_MISMATCH]: DaffCategoryFilterRequestTypeMismatch,
-    [DaffCategoryFilterErrorCodes.FILTER_REQUEST_NAME_MISMATCH]: DaffCategoryFilterRequestNameMismatch,
-    [DaffCategoryFilterErrorCodes.FILTER_NOT_FOUND]: DaffCategoryFilterNotFound,
-    [DaffCategoryFilterErrorCodes.UNKNOWN_FILTER_TYPE]: DaffCategoryUnknownFilterType,
-};
-
-/**
- * A mapping from error codes to error class constructors.
- */
-const DaffCategoryErrorMap = {
-    ...DaffCategoryFiltersErrorMap,
-};
-
 /**
  * Transforms `DaffError`s into `DaffStateError`s before they are serialized into state.
  * Can be used to further refine Daffodil errors into more specific app errors.
  */
 const DAFF_CATEGORY_ERROR_MATCHER = new InjectionToken('DAFF_CATEGORY_ERROR_MATCHER', { factory: () => daffTransformErrorToStateError });
 
-/**
- * Applies a {@link DaffCategoryFilterEqualRequest} to a {@link DaffCategoryFilterEqual}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffApplyFilterEqual = (request, filter) => ({
-    ...filter,
-    options: request.value.reduce((acc, value) => {
-        const option = filter.options[value];
-        if (option) {
-            acc[value] = {
-                ...option,
-                applied: true,
-            };
-        }
-        return acc;
-    }, { ...filter.options }),
-});
-
-const daffCategoryComputeFilterRangePairLabel = (min, max) => `${min}${DaffCategoryFromToFilterSeparator}${max}`;
-
-/**
- * Applies a {@link DaffCategoryFilterRangeRequestBase} to a {@link DaffCategoryFilterRangeBase}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffApplyFilterRange = (request, filter) => ({
-    ...filter,
-    options: {
-        [daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]: {
-            min: {
-                value: request.value.min,
-                label: String(request.value.min),
-            },
-            max: {
-                value: request.value.max,
-                label: String(request.value.max),
-            },
-            applied: true,
-        },
-    },
-});
-
-/**
- * Ensures that the names of the filter and the filter request match.
- *
- * @throws {@link DaffCategoryFilterNotFound} if the names do not match.
- */
-const daffCategoryValidateFilterRequestNameMatch = (request, filter) => {
-    if (!filter) {
-        throw new DaffCategoryFilterNotFound('Filter does not exist');
-    }
-    if (request.name !== filter.name) {
-        throw new DaffCategoryFilterRequestNameMismatch('Filter name does not match request name');
-    }
-};
-
-/**
- * Ensures that the types of the filter and the filter request match.
- *
- * @throws {@link DaffCategoryFilterRequestTypeMismatch} if the types do not match.
- */
-const daffCategoryValidateFilterRequestTypeMatch = (request, filter) => {
-    if (request.type !== filter.type) {
-        throw new DaffCategoryFilterRequestTypeMismatch('Filter types don\'t match');
-    }
-};
-
-/**
- * Applies a filter request to the matching filter.
- *
- * @idempotent {filter}
- * @throws {@link DaffCategoryUnknownFilterType}
- */
-const daffApplyFilter = (request, filter) => {
-    daffCategoryValidateFilterRequestNameMatch(request, filter);
-    daffCategoryValidateFilterRequestTypeMatch(request, filter);
-    switch (request.type) {
-        case DaffCategoryFilterType.Equal:
-            return daffApplyFilterEqual(request, filter);
-        case (DaffCategoryFilterType.RangeNumeric):
-            return daffApplyFilterRange(request, filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-};
-
-/**
- * Applies a {@link DaffCategoryFilterRequest} to a {@link Dict} of {@link DaffCategoryFilter}
- * returning the updated {@link Dict}.
- *
- * @idempotent {filters}
- */
-const daffApplyRequestToFilters = (request, filters) => ({
-    ...filters,
-    [request.name]: daffApplyFilter(request, filters[request.name]),
-});
-
-/**
- * Applies filters from a {@link DaffCategoryFilterRequest} to a {@link Dict}
- * of {@link DaffCategoryFilter}.
- *
- * @idempotent {filters}
- */
-const daffApplyRequestsToFilters = (filtersRequests, filters) => filtersRequests.reduce((acc, request) => {
-    acc[request.name] = daffApplyFilter(request, filters[request.name]);
-    return acc;
-}, { ...filters });
-
-/**
- * Unapplies the applied filter options of a {@link DaffCategoryFilterEqual}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffClearFilterEqual = (filter) => ({
-    ...filter,
-    options: Object.keys(filter.options).map((key) => filter.options[key]).reduce((acc, option) => {
-        acc[option.value] = {
-            ...option,
-            applied: false,
-        };
-        return acc;
-    }, { ...filter.options }),
-});
-
-/**
- * Unapplies the applied filter options of a {@link DaffCategoryFilterRangeBase}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffClearFilterRange = (filter) => ({
-    ...filter,
-    options: {},
-});
-
-/**
- * Undoes the applied state of all applied filter options of a {@link DaffCategoryFilter}
- * returning the filter.
- *
- * @idempotent {filter}
- */
-const daffClearFilter = (filter) => {
-    switch (filter.type) {
-        case DaffCategoryFilterType.RangeNumeric:
-            return daffClearFilterRange(filter);
-        case DaffCategoryFilterType.Equal:
-            return daffClearFilterEqual(filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-};
-
-/**
- * Undoes the applied state of all applied filter options of a {@link Dict} of {@link DaffCategoryFilter}
- * returning updated {@link Dict}.
- *
- * @idempotent {filters}
- */
-const daffClearFilters = (filters) => Object.keys(filters).map((key) => filters[key]).reduce((acc, filter) => {
-    acc[filter.name] = daffClearFilter(filter);
-    return acc;
-}, {});
-
-/**
- * Removes the matching filter options of a {@link DaffCategoryFilterEqual}
- * that match the {@link DaffCategoryFilterEqualRequest}
- *
- * If there are no matching options, returns the original {@link DaffCategoryFilterEqual}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffRemoveFilterEqual = (request, filter) => ({
-    ...filter,
-    options: request.value.reduce((acc, value) => {
-        const option = filter.options[value];
-        if (option) {
-            acc[value] = {
-                ...option,
-                applied: false,
-            };
-        }
-        return acc;
-    }, { ...filter.options }),
-});
-
-/**
- * Removes the matching filter options of a {@link DaffCategoryFilterRangeBase}
- * that match the {@link DaffCategoryFilterRangeRequestBase}
- *
- * If there are no matching options, returns the original {@link DaffCategoryFilterRangeBase}
- *
- * @idempotent {filter}
- * @docs-private
- */
-const daffRemoveFilterRange = (request, filter) => filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
-    ? ({
-        ...filter,
-        options: {},
-    })
-    : filter;
-
-/**
- * Undoes any applied options of a {@link DaffCategoryFilter} that match the
- * {@link DaffCategoryFilterRequest}, returning the {@link DaffCategoryFilter}.
- *
- * @idempotent {filter}
- * @pure
- */
-const daffRemoveFilter = (request, filter) => {
-    daffCategoryValidateFilterRequestNameMatch(request, filter);
-    daffCategoryValidateFilterRequestTypeMatch(request, filter);
-    switch (request.type) {
-        case DaffCategoryFilterType.Equal:
-            return daffRemoveFilterEqual(request, filter);
-        case (DaffCategoryFilterType.RangeNumeric):
-            return daffRemoveFilterRange(request, filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-};
-
-/**
- * Undoes any applied options of a particular filter of a {@link Dict} of {@link DaffCategoryFilter}
- * that match the {@link DaffCategoryFilterRequest}, returning the {@link Dict} of {@link DaffCategoryFilter}.
- *
- * @idempotent {filters}
- */
-const daffRemoveRequestFromFilters = (request, filters) => ({
-    ...filters,
-    [request.name]: daffRemoveFilter(request, filters[request.name]),
-});
-
-/**
- * Undoes all applied options of a {@link Dict} of {@link DaffCategoryFilter}
- * that match any of the {@link DaffCategoryFilterRequest},
- * returning the updated {@link Dict} of {@link DaffCategoryFilter}.
- *
- * @idempotent {filters}
- */
-const daffRemoveRequestsFromFilters = (requests, filters) => requests.reduce((acc, request) => {
-    acc[request.name] = daffRemoveFilter(request, filters[request.name]);
-    return acc;
-}, { ...filters });
-
-/**
- * Oscillates the applied state of the matching filter options of a {@link DaffCategoryFilterEqual}
- * that match the {@link DaffCategoryFilterEqualRequest}
- *
- * If there are no matching options, returns the original {@link DaffCategoryFilterEqual}
- *
- * @docs-private
- */
-const daffToggleFilterEqual = (request, filter) => {
-    const option = filter.options[request.value];
-    return option
-        ? {
-            ...filter,
-            options: {
-                ...filter.options,
-                [option.value]: {
-                    ...option,
-                    applied: !option.applied,
-                },
-            },
-        }
-        : filter;
-};
-
-/**
- * Oscillates the applied state of the matching filter options of a {@link DaffCategoryFilterRangeBase}
- * that match the {@link DaffCategoryFilterRangeRequestBase}
- *
- * If there are no matching options, returns the original {@link DaffCategoryFilterRangeBase}
- *
- * @docs-private
- */
-const daffToggleFilterRange = (request, filter) => filter.options[daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max)]
-    ? daffRemoveFilterRange(request, filter)
-    : daffApplyFilterRange(request, filter);
-
-/**
- * Toggles the state of the filters (and their options) in the {@link DaffCategoryFilter}
- * that match the {@link DaffCategoryFilterToggleRequest} .
- */
-function daffToggleFilter(request, filter) {
-    daffCategoryValidateFilterRequestNameMatch(request, filter);
-    daffCategoryValidateFilterRequestTypeMatch(request, filter);
-    switch (request.type) {
-        case DaffCategoryFilterType.Equal:
-            return daffToggleFilterEqual(request, filter);
-        case (DaffCategoryFilterType.RangeNumeric):
-            return daffToggleFilterRange(request, filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-}
-
-/**
- * Toggles the state of a filter option in the {@link Dict<DaffCategoryFilter>}
- * that matches the {@link DaffCategoryFilterToggleRequest}.
- */
-const daffToggleRequestOnFilters = (request, filters) => ({
-    ...filters,
-    [request.name]: daffToggleFilter(request, filters[request.name]),
-});
-
-/**
- * Determines whether or not the {@link DaffCategoryFilterEqual} has any applied options.
- */
-const daffIsFilterEqualApplied = (filter) => Object.keys(filter.options).map((key) => filter.options[key]).findIndex(option => option.applied) > -1;
-
-/**
- * Determines whether or not a {@link DaffCategoryFilterRangeBase} has any applied options.
- */
-const daffIsFilterRangeApplied = (filter) => Object.keys(filter.options).length > 0;
-
-/**
- * Determines whether or not a filter has any currently applied options.
- */
-const daffIsFilterApplied = (filter) => {
-    switch (filter.type) {
-        case DaffCategoryFilterType.RangeNumeric:
-            return daffIsFilterRangeApplied(filter);
-        case DaffCategoryFilterType.Equal:
-            return daffIsFilterEqualApplied(filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-};
-
-/**
- * Determines whether or not any {@link DaffCategoryFilterEqual} options matching {@link DaffCategoryFilterEqualToggleRequest} are applied.
- */
-const daffIsEqualToggleRequestAppliedToFilter = (request, filter) => !!filter.options[request.value]?.applied;
-
-/**
- * Determines whether or not any {@link DaffCategoryFilterRangeBase} options matching {@link DaffCategoryFilterRangeRequestBase} are applied.
- */
-const daffIsRangeToggleRequestAppliedToFilter = (request, filter) => daffCategoryComputeFilterRangePairLabel(request.value.min, request.value.max) in filter.options;
-
-/**
- * Determines whether or not a {@link DaffCategoryFilterToggleRequest} is already applied to a {@link DaffCategoryFilter}.
- */
-const daffIsToggleRequestAppliedToFilter = (request, filter) => {
-    switch (filter.type) {
-        case DaffCategoryFilterType.RangeNumeric:
-            return daffIsRangeToggleRequestAppliedToFilter(request, filter);
-        case DaffCategoryFilterType.Equal:
-            return daffIsEqualToggleRequestAppliedToFilter(request, filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-};
-
-/**
- * Finds the applied options in the filter.
- */
-const daffCategoryFindAppliedFilterOptions = (filter) => Object.keys(filter.options).map((key) => filter.options[key]).filter((option) => option.applied);
-
-/**
- * Builds an {@link DaffCategoryFilterEqualRequest} from the passed filter and options.
- */
-const daffCategoryFilterEqualToRequest = (filter) => {
-    const options = daffCategoryFindAppliedFilterOptions(filter);
-    if (!options.length) {
-        return null;
-    }
-    return {
-        type: DaffCategoryFilterType.Equal,
-        name: filter.name,
-        value: options.map(option => option.value),
-    };
-};
-
-/**
- * Builds a {@link DaffCategoryFilterRangeRequestBase} from the passed {@link DaffCategoryFilterRangeBase} and options.
- */
-const daffCategoryFilterRangeToRequest = (filter) => {
-    const options = daffCategoryFindAppliedFilterOptions(filter);
-    if (!options.length) {
-        return null;
-    }
-    return {
-        type: filter.type,
-        name: filter.name,
-        value: {
-            min: options[0].min.value,
-            max: options[0].max.value,
-        },
-    };
-};
-
-/**
- * Transforms a {@link DaffCategoryFilterRangeNumeric} into a {@link DaffCategoryFilterRangeNumericRequest}
- */
-const daffCategoryFilterRangeNumericToRequest = (filter) => daffCategoryFilterRangeToRequest(filter);
-
-/**
- * Builds a category filter request from a category filter.
- * Returns null if the category filter does not have at least one applied option.
- */
-function daffCategoryFilterToRequest(filter) {
-    switch (filter.type) {
-        case DaffCategoryFilterType.RangeNumeric:
-            return daffCategoryFilterRangeNumericToRequest(filter);
-        case DaffCategoryFilterType.Equal:
-            return daffCategoryFilterEqualToRequest(filter);
-        default:
-            throw new DaffCategoryUnknownFilterType('Unknown filter type');
-    }
-}
-;
-
-/**
- * Builds a list of filter requests from a list of filters.
- * Requests are only built for the filters that have at least one applied option.
- */
-function daffCategoryFiltersToRequests(filters) {
-    return Object.keys(filters).map((key) => filters[key]).reduce((acc, filter) => {
-        const request = daffCategoryFilterToRequest(filter);
-        if (request) {
-            acc.push(request);
-        }
-        return acc;
-    }, []);
-}
-
-/**
- * Transforms an {@link DaffCategoryFilterRangePair[]} to a {@link Dict<DaffCategoryFilterRangePair>}.
- */
-const daffCategoryFilterRangePairArrayToDict = (pairs) => daffArrayToDict(pairs, pair => daffCategoryComputeFilterRangePairLabel(pair.min.value, pair.max.value));
-
-/**
- * Converts a list of category equal filter options to a dict of options keyed by option value.
- */
-const daffCategoryFilterEqualOptionArrayToDict = (options) => daffArrayToDict(options, option => option.value);
-
-/**
- * Converts a list of category filters into a {@link Dict} of filters keyed by filter name.
- */
-const daffCategoryFilterArrayToDict = (filters) => daffArrayToDict(filters, filter => filter.name);
-
-/**
- * Returns a {@link Dict<DaffCategoryFilter>} and only their applied options.
- * {@link DaffCategoryFilter} that have no applied options will be omitted.
- */
-const daffCategoryComputeAppliedFilters = (filters) => Object.keys(filters).map(key => filters[key]).reduce((acc, filter) => {
-    const appliedOptions = daffCategoryFindAppliedFilterOptions(filter);
-    if (appliedOptions.length > 0) {
-        acc[filter.name] = {
-            ...filter,
-            options: filter.type === DaffCategoryFilterType.Equal
-                ? daffCategoryFilterEqualOptionArrayToDict(appliedOptions)
-                : daffCategoryFilterRangePairArrayToDict(appliedOptions),
-        };
-    }
-    return acc;
-}, {});
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { DAFF_CATEGORY_ERROR_MATCHER, DaffCategoryErrorCodes, DaffCategoryErrorMap, DaffCategoryFilterNotFound, DaffCategoryFilterRequestNameMismatch, DaffCategoryFilterRequestTypeMismatch, DaffCategoryFilterType, DaffCategoryFromToFilterSeparator, DaffCategoryRequestKind, DaffCategoryUnknownFilterType, daffApplyFilter, daffApplyRequestToFilters, daffApplyRequestsToFilters, daffCategoryComputeAppliedFilters, daffCategoryComputeFilterRangePairLabel, daffCategoryFilterArrayToDict, daffCategoryFilterEqualOptionArrayToDict, daffCategoryFilterRangePairArrayToDict, daffCategoryFilterToRequest, daffCategoryFiltersToRequests, daffCategoryFindAppliedFilterOptions, daffCategoryValidateFilterRequestNameMatch, daffCategoryValidateFilterRequestTypeMatch, daffClearFilter, daffClearFilters, daffIsFilterApplied, daffIsToggleRequestAppliedToFilter, daffRemoveFilter, daffRemoveRequestFromFilters, daffRemoveRequestsFromFilters, daffToggleFilter, daffToggleRequestOnFilters };
+export { DAFF_CATEGORY_ERROR_MATCHER, DaffCategoryRequestKind };
 //# sourceMappingURL=daffodil-category.mjs.map