Function buildProviderData

scripts/sync/build.ts:129–173

(
  provider: SourceProvider,
  baseDir: string,
  context: BuildContext = {}
)

}

export async function buildProviderData(
  provider: SourceProvider,
  baseDir: string,
  context: BuildContext = {}
): Promise<SourceProviderData> {
  const normalizedProvider = sourceProviderSchema.parse(provider);
  const fetcher = context.fetcher ?? defaultFetcher;
  const sourceRules = await loadSourceRules(normalizedProvider.sources, baseDir, fetcher, context.cache);
  const removeRules = normalizePartialRuleSet(normalizedProvider.patch.remove);
  const explicitRules = mergeRuleSets(
    normalizedProvider.groups.map((group) => normalizePartialRuleSet(group.include))
  );
  let remainingSourceRules = subtractRuleSet(subtractRuleSet(sourceRules, removeRules), explicitRules);

  const groups: RuleGroup[] = [];

  for (const group of normalizedProvider.groups) {
    const includeRules = normalizePartialRuleSet(group.include);
    const requestedKeys = resolveFromSourceKeys(group.fromSource);
    const sourceGroupRules = pickRuleKeys(remainingSourceRules, requestedKeys);
    let rules = mergeRuleSets([includeRules, sourceGroupRules]);
    rules = subtractRuleSet(rules, removeRules);

    groups.push({
      name: group.name,
      rules
    });

    if (requestedKeys.length > 0) {
      remainingSourceRules = subtractRuleSet(remainingSourceRules, sourceGroupRules);
    }
  }

  const normalizedGroups = compactGroups(removeCoveredDomains(groups.map((group) => group.rules)), groups);

  return {
    provider: normalizedProvider.provider,
    name: normalizedProvider.name,
    description: normalizedProvider.description,
    categories: normalizedProvider.categories,
    aliases: normalizedProvider.aliases,
    allowDangerousDomainSuffix: normalizedProvider.allowDangerousDomainSuffix,
    groups: normalizedGroups
  };
}

function resolveFromSourceKeys(value: boolean | RuleKey[]): RuleKey[] {
  if (value === true) {