9237685791

Committed 25 May 2024 07:18PM UTC coverage: 92.43% (-0.1%) from 92.525%

Build # 9237685791

Build Type

push

github

Committed by

arlac77

Commit Message

fix: throw on content definition errors

Run Details

371 of 445 branches covered (83.37%)

Branch coverage included in aggregate %.

10 of 15 new or added lines in 1 file covered. (66.67%)

1 existing line in 1 file now uncovered.

2779 of 2963 relevant lines covered (93.79%)

22.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.13

/src/extract-from-package.mjs

import { join, resolve } from "node:path";
import { packageDirectory } from "pkg-dir";
import { packageWalker } from "npm-package-walker";
import { createContext } from "expression-expander";
import { satisfies } from "compare-versions";
import { asArray, mergeDependencies } from "./util.mjs";
import { NPMPackContentProvider } from "./content/npm-pack-content-provider.mjs";
import { NodeModulesContentProvider } from "./content/node-modules-content-provider.mjs";
import { FileContentProvider } from "./content/file-content-provider.mjs";
import { NFTContentProvider } from "./content/nft-content-provider.mjs";
import { ContentProvider } from "./content/content-provider.mjs";
import { DEBIAN } from "./output/debian.mjs";
import { ARCH } from "./output/arch.mjs";
import { RPM } from "./output/rpm.mjs";
import { OCI } from "./output/oci.mjs";
import { DOCKER } from "./output/docker.mjs";
import { BUILDAH } from "./output/buildah.mjs";

/**
 * All content providers
 */
export const allInputs = [
  NPMPackContentProvider,
  NodeModulesContentProvider,
  NFTContentProvider,
  FileContentProvider
];

/**
 * All output formats
 */
export const allOutputs = [DEBIAN, ARCH, RPM, OCI, DOCKER, BUILDAH];

/**
 * Node architecture name to os native arch name mapping
 * {@see https://nodejs.org/dist/latest-v18.x/docs/api/process.html#processargv}
 */
export const npmArchMapping = {
  arm64: "aarch64",
  arm: "armv7h",
  mips: "mips",
  mipsel: "mipsel",
  ppc: "ppc",
  s390: "s390",
  s390x: "s390x",
  ia32: "x32",
  x64: "x86_64",
  ppc64: "ppc64"
};

const entryAttributeNames = ["owner", "group", "mode"];

function mergeArchs(a, b) {
  if (a) {
    if (b) {
      return [...a, ...b];
    }
    return a;
  }
  return b;
}

/**
 * Delivers ContentProviders from pkgbuild.content definition.
 * @param {Object} content from pkgbuild.content
 * @returns {Iterable<ContentProvider>}
 */
function* content2Sources(content, dir) {
  for (const [destination, definitions] of Object.entries(content)) {
    const allEntryProperties = {};

    for (const a of entryAttributeNames) {
      if (definitions[a] !== undefined) {
        allEntryProperties[a] = definitions[a];
        delete definitions[a];
      }
    }

    for (let definition of asArray(definitions)) {
      const entryProperties = { ...allEntryProperties, destination };

      if (definition.type) {
        const type = allInputs.find(i => i.name === definition.type);
        if (type) {
          delete definition.type;
          yield new type({ ...definition, dir }, entryProperties);
        } else {
          throw new Error(`Unknown content provider '${type}'`);
        }
      } else {
        switch (typeof definition) {
          case "object":
            definition.base = definition.base
              ? join(dir, definition.base)
              : dir;
            break;
          case "string":
            definition = join(dir, definition);
            break;
          default:
            throw new Error(`Unsupported content value '${definition}'`);
        }
        yield new FileContentProvider(definition, entryProperties);
      }
    }
  }
}

/**
 * @typedef {Object} PackageDefinition
 * @property {Object} properties values describing the package attributes
 * @property {ContentProvider[]} sources content providers
 * @property {Object} dependencies
 * @property {Object} output package type
 * @property {Object} variant identifier of the variant
 * @property {string} variant.name name of the variant
 * @property {string} variant.arch name of the architecture
 */

/**
 * Extract package definition from package.json.
 * - for each architecture deliver a new result
 * - if no architecture is given one result set is provided nethertheless
 * - architectures are taken from cpu (node arch ids) and from pkgbuild.arch (raw arch ids)
 * - architecture given in a variant definition are used to restrict the set of avaliable architectures
 * @param {Object} options
 * @param {string} [options.dir] where to look for package.json
 * @param {boolean} [options.verbose] log
 * @param {Object} env as delared in process.env
 * @returns {AsyncIterable<PackageDefinition>}
 */
export async function* extractFromPackage(options = {}, env = {}) {
  const variants = {};
  const fragments = {};
  let root, parent;

  const packages = new Map();

  await packageWalker(async (packageContent, dir, modulePath) => {
    let i = 0;

    packages.set(packageContent.name, packageContent.version);

    for (const pkgbuild of asArray(packageContent.pkgbuild)) {
      if (modulePath.length > 0 && !pkgbuild.variant) {
        continue;
      }

      const requires = pkgbuild.requires;
      delete pkgbuild.requires;

      let name = `${packageContent.name}[${i++}]`;
      let priority = 1;

      if (requires) {
        let fullfilled = true;

        if (requires.properties) {
          for (const [k, v] of Object.entries(requires.properties)) {
            if (root.properties[k] !== v && options[k] !== v) {
              fullfilled = false;
              break;
            }

            priority += 1;
          }
        }

        if (requires.environment) {
          if (env[requires.environment.has] === undefined) {
            fullfilled = false;
          }
          priority += 10;
        }

        if (fullfilled) {
          if (options.verbose) {
            console.log(`${name}: requirement fullfilled`, requires);
          }
        } else {
          if (options.verbose) {
            console.log(`${name}: requirement not fullfilled`, requires);
          }
          continue;
        }
      } else {
        if (options.verbose) {
          console.log(`${name}: load`);
        }
      }

      const fragment = {
        dir,
        name,
        requires,
        priority,
        dependencies: packageContent.engines || {},
        arch: new Set(),
        restrictArch: new Set()
      };

      if (packageContent.cpu) {
        for (const a of asArray(packageContent.cpu)) {
          fragment.arch.add(npmArchMapping[a]);
        }
      }

      if (pkgbuild.arch) {
        for (const a of asArray(pkgbuild.arch)) {
          if (modulePath.length === 0) {
            fragment.arch.add(a);
          } else {
            fragment.restrictArch.add(a);
          }
        }
        delete pkgbuild.arch;
      }

      for (const k of ["hooks"]) {
        if (pkgbuild[k]) {
          pkgbuild[k] = resolve(dir, pkgbuild[k]);
        }
      }

      for (const k of ["output", "content", "dependencies"]) {
        if (pkgbuild[k]) {
          fragment[k] = pkgbuild[k];
          delete pkgbuild[k];
        }
      }

      const properties = {};

      if (modulePath.length >= 1) {
        fragment.parent =
          modulePath.length === 1 ? parent : modulePath[modulePath.length - 2];
      } else {
        properties.access = packageContent?.publishConfig?.access || "private";

        Object.assign(
          properties,
          packageContent.config,
          Object.fromEntries(
            ["name", "version", "description", "homepage", "license"]
              .map(key => [key, packageContent[key]])
              .filter(([k, v]) => v !== undefined)
          )
        );

        if (properties.name) {
          properties.name = properties.name.replace(/^\@[^\/]+\//, "");
        }

        if (packageContent.bugs?.url) {
          properties.bugs = packageContent.bugs.url;
        }

        if (packageContent.bin) {
          properties.entrypoints = packageContent.bin;
        }

        if (packageContent.contributors) {
          properties.maintainer = packageContent.contributors.map(
            c => `${c.name} <${c.email}>`
          );
        }

        if (typeof packageContent.repository === "string") {
          properties.source = packageContent.repository;
        } else {
          if (packageContent.repository?.url) {
            properties.source = packageContent.repository.url;
          }
        }
      }

      fragment.properties = Object.assign(properties, pkgbuild);
      fragments[fragment.name] = fragment;

      if (pkgbuild.variant) {
        variants[pkgbuild.variant] = fragment;
      }

      if (modulePath.length === 0) {
        root = fragment;
      }
      parent = fragment.name;
    }

    return true;
  }, await packageDirectory({ cwd: options.dir }));

  if (root && Object.keys(variants).length === 0) {
    // @ts-ignore
    variants.default = root;
  }

  for (const [name, variant] of Object.entries(variants).sort(
    ([ua, a], [ub, b]) => b.priority - a.priority
  )) {
    let arch = variant.arch;
    let properties = {};
    let dependencies = {};
    const output = {};
    const content = [];

    for (
      let fragment = variant;
      fragment;
      fragment = fragments[fragment.parent]
    ) {
      const missedRequirements = [];

      const requires = fragment.requires;
      if (requires) {
        if (requires.output && !output[requires.output]) {
          missedRequirements.push(`output ${requires.output} not avaliable`);
        }
        if (requires.dependencies) {
          for (const [p, v] of Object.entries(requires.dependencies)) {
            const pkgVersion = packages.get(p);

            if (pkgVersion === undefined || !satisfies(pkgVersion, v)) {
              missedRequirements.push(`package not present ${p} ${v}`);
              break;
            }
          }
        }
      }

      if (missedRequirements.length === 0) {
        arch = new Set([...arch, ...fragment.arch]);
        properties = { ...fragment.properties, ...properties };
        dependencies = mergeDependencies(dependencies, fragment.dependencies);
        Object.assign(output, fragment.output);
        if (fragment.content) {
          content.push([fragment.content, fragment.dir]);
        }
      } else {
        console.log("requirements not met", fragment.name, missedRequirements);
      }
    }

    // @ts-ignore
    Object.assign(properties, root.properties);
    delete properties.dependencies;

    properties.variant = name;

    const context = createContext({ properties });
    const sources = context.expand(content).reduce((a, c) => {
      a.push(...content2Sources(c[0], c[1]));
      return a;
    }, []);

    const result = {
      context,
      variant: { name, priority: variant.priority },
      sources,
      output,
      dependencies,
      properties: context.expand(properties)
    };

    function* forEachOutput(result) {
      if (Object.entries(result.output).length === 0) {
        yield result;
      }

      for (const [name, output] of Object.entries(result.output)) {
        const arch = mergeArchs(
          result.properties.arch,
          output.properties?.arch
        );
        if (arch !== undefined) {
          result.properties.arch = arch;
        }

        let sources = [];

        if (output.content) {
          sources = context
            .expand([[output.content, variant.dir]])
            .reduce((a, c) => {
              a.push(...content2Sources(c[0], c[1]));
              return a;
            }, []);
        }

        const outputResult = {
          ...result,
          variant: { ...result.variant, output: name },
          output: { [name]: output },
          sources: [...result.sources, ...sources],
          dependencies: mergeDependencies(
            result.dependencies,
            output.dependencies
          ),
          properties: {
            type: name,
            ...result.properties,
            ...output.properties
          }
        };

        /*
        console.log(
          "RESULT",
          outputResult.variant,
          outputResult.properties,
          sources.map(s => s.toString()).join("\n"),
          outputResult.output
        );*/

        yield outputResult;
      }
    }

    if (arch.size === 0) {
      yield* forEachOutput(result);
    } else {
      for (const a of [...arch].sort()) {
        if (variant.restrictArch.size === 0 || variant.restrictArch.has(a)) {
          result.variant.arch = a;
          result.properties.arch = [a];
          yield* forEachOutput(result);
        }
      }
    }
  }
}

1	import { join, resolve } from "node:path";	28✔
2	import { packageDirectory } from "pkg-dir";	28✔
3	import { packageWalker } from "npm-package-walker";	28✔
4	import { createContext } from "expression-expander";	28✔
5	import { satisfies } from "compare-versions";	28✔
6	import { asArray, mergeDependencies } from "./util.mjs";	28✔
7	import { NPMPackContentProvider } from "./content/npm-pack-content-provider.mjs";	28✔
8	import { NodeModulesContentProvider } from "./content/node-modules-content-provider.mjs";	28✔
9	import { FileContentProvider } from "./content/file-content-provider.mjs";	28✔
10	import { NFTContentProvider } from "./content/nft-content-provider.mjs";	28✔
11	import { ContentProvider } from "./content/content-provider.mjs";	28✔
12	import { DEBIAN } from "./output/debian.mjs";	28✔
13	import { ARCH } from "./output/arch.mjs";	28✔
14	import { RPM } from "./output/rpm.mjs";	28✔
15	import { OCI } from "./output/oci.mjs";	28✔
16	import { DOCKER } from "./output/docker.mjs";	28✔
17	import { BUILDAH } from "./output/buildah.mjs";	28✔
18		28✔
19	/**	28✔
20	* All content providers	28✔
21	*/	28✔
22	export const allInputs = [	28✔
23	NPMPackContentProvider,	28✔
24	NodeModulesContentProvider,	28✔
25	NFTContentProvider,	28✔
26	FileContentProvider	28✔
27	];	28✔
28		28✔
29	/**	28✔
30	* All output formats	28✔
31	*/	28✔
32	export const allOutputs = [DEBIAN, ARCH, RPM, OCI, DOCKER, BUILDAH];	28✔
33		28✔
34	/**	28✔
35	* Node architecture name to os native arch name mapping	28✔
36	* {@see https://nodejs.org/dist/latest-v18.x/docs/api/process.html#processargv}	28✔
37	*/	28✔
38	export const npmArchMapping = {	28✔
39	arm64: "aarch64",	28✔
40	arm: "armv7h",	28✔
41	mips: "mips",	28✔
42	mipsel: "mipsel",	28✔
43	ppc: "ppc",	28✔
44	s390: "s390",	28✔
45	s390x: "s390x",	28✔
46	ia32: "x32",	28✔
47	x64: "x86_64",	28✔
48	ppc64: "ppc64"	28✔
49	};	28✔
50		28✔
51	const entryAttributeNames = ["owner", "group", "mode"];	28✔
52		28✔
53	function mergeArchs(a, b) {	16✔
54	if (a) {	16✔
55	if (b) {	12!
56	return [...a, ...b];	×
57	}	×
58	return a;	12✔
59	}	12✔
60	return b;	4✔
61	}	16✔
62		28✔
63	/**	28✔
64	* Delivers ContentProviders from pkgbuild.content definition.	28✔
65	* @param {Object} content from pkgbuild.content	28✔
66	* @returns {Iterable<ContentProvider>}	28✔
67	*/	28✔
68	function* content2Sources(content, dir) {	12✔
69	for (const [destination, definitions] of Object.entries(content)) {	12✔
70	const allEntryProperties = {};	16✔
71		16✔
72	for (const a of entryAttributeNames) {	16✔
73	if (definitions[a] !== undefined) {	48✔
74	allEntryProperties[a] = definitions[a];	2✔
75	delete definitions[a];	2✔
76	}	2✔
77	}	48✔
78		16✔
79	for (let definition of asArray(definitions)) {	16✔
80	const entryProperties = { ...allEntryProperties, destination };	22✔
81		22✔
82	if (definition.type) {	22✔
83	const type = allInputs.find(i => i.name === definition.type);	2✔
84	if (type) {	2✔
85	delete definition.type;	2✔
86	yield new type({ ...definition, dir }, entryProperties);	2✔
87	} else {	2!
NEW 88	throw new Error(`Unknown content provider '${type}'`);	×
89	}	×
90	} else {	22✔
91	switch (typeof definition) {	20✔
92	case "object":	20✔
93	definition.base = definition.base	6✔
94	? join(dir, definition.base)	6✔
95	: dir;	6✔
96	break;	6✔
97	case "string":	20✔
98	definition = join(dir, definition);	14✔
99	break;	14✔
100	default:	20!
NEW 101	throw new Error(`Unsupported content value '${definition}'`);	×
102	}	20✔
103	yield new FileContentProvider(definition, entryProperties);	20✔
104	}	20✔
105	}	22✔
106	}	16✔
107	}	12✔
108		28✔
109	/**	28✔
110	* @typedef {Object} PackageDefinition	28✔
111	* @property {Object} properties values describing the package attributes	28✔
112	* @property {ContentProvider[]} sources content providers	28✔
113	* @property {Object} dependencies	28✔
114	* @property {Object} output package type	28✔
115	* @property {Object} variant identifier of the variant	28✔
116	* @property {string} variant.name name of the variant	28✔
117	* @property {string} variant.arch name of the architecture	28✔
118	*/	28✔
119		28✔
120	/**	28✔
121	* Extract package definition from package.json.	28✔
122	* - for each architecture deliver a new result	28✔
123	* - if no architecture is given one result set is provided nethertheless	28✔
124	* - architectures are taken from cpu (node arch ids) and from pkgbuild.arch (raw arch ids)	28✔
125	* - architecture given in a variant definition are used to restrict the set of avaliable architectures	28✔
126	* @param {Object} options	28✔
127	* @param {string} [options.dir] where to look for package.json	28✔
128	* @param {boolean} [options.verbose] log	28✔
129	* @param {Object} env as delared in process.env	28✔
130	* @returns {AsyncIterable<PackageDefinition>}	28✔
131	*/	28✔
132	export async function* extractFromPackage(options = {}, env = {}) {	28✔
133	const variants = {};	26✔
134	const fragments = {};	26✔
135	let root, parent;	26✔
136		26✔
137	const packages = new Map();	26✔
138		26✔
139	await packageWalker(async (packageContent, dir, modulePath) => {	26✔
140	let i = 0;	36✔
141		36✔
142	packages.set(packageContent.name, packageContent.version);	36✔
143		36✔
144	for (const pkgbuild of asArray(packageContent.pkgbuild)) {	36✔
145	if (modulePath.length > 0 && !pkgbuild.variant) {	34!
146	continue;	×
147	}	×
148		34✔
149	const requires = pkgbuild.requires;	34✔
150	delete pkgbuild.requires;	34✔
151		34✔
152	let name = `${packageContent.name}[${i++}]`;	34✔
153	let priority = 1;	34✔
154		34✔
155	if (requires) {	34✔
156	let fullfilled = true;	8✔
157		8✔
158	if (requires.properties) {	8✔
159	for (const [k, v] of Object.entries(requires.properties)) {	4✔
160	if (root.properties[k] !== v && options[k] !== v) {	4✔
161	fullfilled = false;	2✔
162	break;	2✔
163	}	2✔
164		2✔
165	priority += 1;	2✔
166	}	2✔
167	}	4✔
168		8✔
169	if (requires.environment) {	8✔
170	if (env[requires.environment.has] === undefined) {	2✔
171	fullfilled = false;	2✔
172	}	2✔
173	priority += 10;	2✔
174	}	2✔
175		8✔
176	if (fullfilled) {	8✔
177	if (options.verbose) {	4!
178	console.log(`${name}: requirement fullfilled`, requires);	×
179	}	×
180	} else {	4✔
181	if (options.verbose) {	4!
182	console.log(`${name}: requirement not fullfilled`, requires);	×
183	}	×
184	continue;	4✔
185	}	4✔
186	} else {	34✔
187	if (options.verbose) {	26✔
188	console.log(`${name}: load`);	2✔
189	}	2✔
190	}	26✔
191		30✔
192	const fragment = {	30✔
193	dir,	30✔
194	name,	30✔
195	requires,	30✔
196	priority,	30✔
197	dependencies: packageContent.engines \|\| {},	34✔
198	arch: new Set(),	34✔
199	restrictArch: new Set()	34✔
200	};	34✔
201		34✔
202	if (packageContent.cpu) {	34✔
203	for (const a of asArray(packageContent.cpu)) {	6✔
204	fragment.arch.add(npmArchMapping[a]);	12✔
205	}	12✔
206	}	6✔
207		30✔
208	if (pkgbuild.arch) {	34✔
209	for (const a of asArray(pkgbuild.arch)) {	10✔
210	if (modulePath.length === 0) {	24✔
211	fragment.arch.add(a);	12✔
212	} else {	12✔
213	fragment.restrictArch.add(a);	12✔
214	}	12✔
215	}	24✔
216	delete pkgbuild.arch;	10✔
217	}	10✔
218		30✔
219	for (const k of ["hooks"]) {	30✔
220	if (pkgbuild[k]) {	30✔
221	pkgbuild[k] = resolve(dir, pkgbuild[k]);	4✔
222	}	4✔
223	}	30✔
224		30✔
225	for (const k of ["output", "content", "dependencies"]) {	34✔
226	if (pkgbuild[k]) {	90✔
227	fragment[k] = pkgbuild[k];	18✔
228	delete pkgbuild[k];	18✔
229	}	18✔
230	}	90✔
231		30✔
232	const properties = {};	30✔
233		30✔
234	if (modulePath.length >= 1) {	34✔
235	fragment.parent =	8✔
236	modulePath.length === 1 ? parent : modulePath[modulePath.length - 2];	8!
237	} else {	34✔
238	properties.access = packageContent?.publishConfig?.access \|\| "private";	22✔
239		22✔
240	Object.assign(	22✔
241	properties,	22✔
242	packageContent.config,	22✔
243	Object.fromEntries(	22✔
244	["name", "version", "description", "homepage", "license"]	22✔
245	.map(key => [key, packageContent[key]])	22✔
246	.filter(([k, v]) => v !== undefined)	22✔
247	)	22✔
248	);	22✔
249		22✔
250	if (properties.name) {	22✔
251	properties.name = properties.name.replace(/^\@[^\/]+\//, "");	22✔
252	}	22✔
253		22✔
254	if (packageContent.bugs?.url) {	22!
255	properties.bugs = packageContent.bugs.url;	×
256	}	×
257		22✔
258	if (packageContent.bin) {	22!
259	properties.entrypoints = packageContent.bin;	×
260	}	×
261		22✔
262	if (packageContent.contributors) {	22!
NEW 263	properties.maintainer = packageContent.contributors.map(	×
NEW 264	c => `${c.name} <${c.email}>`	×
NEW 265	);	×
UNCOV 266	}	×
267		22✔
268	if (typeof packageContent.repository === "string") {	22✔
269	properties.source = packageContent.repository;	2✔
270	} else {	22✔
271	if (packageContent.repository?.url) {	20✔
272	properties.source = packageContent.repository.url;	2✔
273	}	2✔
274	}	20✔
275	}	22✔
276		30✔
277	fragment.properties = Object.assign(properties, pkgbuild);	30✔
278	fragments[fragment.name] = fragment;	30✔
279		30✔
280	if (pkgbuild.variant) {	34✔
281	variants[pkgbuild.variant] = fragment;	10✔
282	}	10✔
283		30✔
284	if (modulePath.length === 0) {	34✔
285	root = fragment;	22✔
286	}	22✔
287	parent = fragment.name;	30✔
288	}	30✔
289		36✔
290	return true;	36✔
291	}, await packageDirectory({ cwd: options.dir }));	26✔
292		26✔
293	if (root && Object.keys(variants).length === 0) {	26✔
294	// @ts-ignore	12✔
295	variants.default = root;	12✔
296	}	12✔
297		26✔
298	for (const [name, variant] of Object.entries(variants).sort(	26✔
299	([ua, a], [ub, b]) => b.priority - a.priority	26✔
300	)) {	26✔
301	let arch = variant.arch;	22✔
302	let properties = {};	22✔
303	let dependencies = {};	22✔
304	const output = {};	22✔
305	const content = [];	22✔
306		22✔
307	for (	22✔
308	let fragment = variant;	22✔
309	fragment;	22✔
310	fragment = fragments[fragment.parent]	22✔
311	) {	22✔
312	const missedRequirements = [];	30✔
313		30✔
314	const requires = fragment.requires;	30✔
315	if (requires) {	30✔
316	if (requires.output && !output[requires.output]) {	4!
317	missedRequirements.push(`output ${requires.output} not avaliable`);	×
318	}	×
319	if (requires.dependencies) {	4✔
320	for (const [p, v] of Object.entries(requires.dependencies)) {	2✔
321	const pkgVersion = packages.get(p);	2✔
322		2✔
323	if (pkgVersion === undefined \|\| !satisfies(pkgVersion, v)) {	2!
324	missedRequirements.push(`package not present ${p} ${v}`);	×
325	break;	×
326	}	×
327	}	2✔
328	}	2✔
329	}	4✔
330		30✔
331	if (missedRequirements.length === 0) {	30✔
332	arch = new Set([...arch, ...fragment.arch]);	30✔
333	properties = { ...fragment.properties, ...properties };	30✔
334	dependencies = mergeDependencies(dependencies, fragment.dependencies);	30✔
335	Object.assign(output, fragment.output);	30✔
336	if (fragment.content) {	30✔
337	content.push([fragment.content, fragment.dir]);	8✔
338	}	8✔
339	} else {	30!
340	console.log("requirements not met", fragment.name, missedRequirements);	×
341	}	×
342	}	30✔
343		22✔
344	// @ts-ignore	22✔
345	Object.assign(properties, root.properties);	22✔
346	delete properties.dependencies;	22✔
347		22✔
348	properties.variant = name;	22✔
349		22✔
350	const context = createContext({ properties });	22✔
351	const sources = context.expand(content).reduce((a, c) => {	22✔
352	a.push(...content2Sources(c[0], c[1]));	8✔
353	return a;	8✔
354	}, []);	22✔
355		22✔
356	const result = {	22✔
357	context,	22✔
358	variant: { name, priority: variant.priority },	22✔
359	sources,	22✔
360	output,	22✔
361	dependencies,	22✔
362	properties: context.expand(properties)	22✔
363	};	22✔
364		22✔
365	function* forEachOutput(result) {	22✔
366	if (Object.entries(result.output).length === 0) {	30✔
367	yield result;	20✔
368	}	20✔
369		30✔
370	for (const [name, output] of Object.entries(result.output)) {	30✔
371	const arch = mergeArchs(	16✔
372	result.properties.arch,	16✔
373	output.properties?.arch	16✔
374	);	16✔
375	if (arch !== undefined) {	16✔
376	result.properties.arch = arch;	12✔
377	}	12✔
378		16✔
379	let sources = [];	16✔
380		16✔
381	if (output.content) {	16✔
382	sources = context	4✔
383	.expand([[output.content, variant.dir]])	4✔
384	.reduce((a, c) => {	4✔
385	a.push(...content2Sources(c[0], c[1]));	4✔
386	return a;	4✔
387	}, []);	4✔
388	}	4✔
389		16✔
390	const outputResult = {	16✔
391	...result,	16✔
392	variant: { ...result.variant, output: name },	16✔
393	output: { [name]: output },	16✔
394	sources: [...result.sources, ...sources],	16✔
395	dependencies: mergeDependencies(	16✔
396	result.dependencies,	16✔
397	output.dependencies	16✔
398	),	16✔
399	properties: {	16✔
400	type: name,	16✔
401	...result.properties,	16✔
402	...output.properties	16✔
403	}	16✔
404	};	16✔
405		16✔
406	/*	16✔
407	console.log(	16✔
408	"RESULT",	16✔
409	outputResult.variant,	16✔
410	outputResult.properties,	16✔
411	sources.map(s => s.toString()).join("\n"),	16✔
412	outputResult.output	16✔
413	);*/	16✔
414		16✔
415	yield outputResult;	16✔
416	}	16✔
417	}	30✔
418		22✔
419	if (arch.size === 0) {	22✔
420	yield* forEachOutput(result);	12✔
421	} else {	12✔
422	for (const a of [...arch].sort()) {	10✔
423	if (variant.restrictArch.size === 0 \|\| variant.restrictArch.has(a)) {	18✔
424	result.variant.arch = a;	18✔
425	result.properties.arch = [a];	18✔
426	yield* forEachOutput(result);	18✔
427	}	18✔
428	}	18✔
429	}	10✔
430	}	22✔
431	}	26✔

arlac77 / npm-pkgbuild / 9237685791

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous