@gen3/toolsff 0.10.44

package/dist/buildColors.esm.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import tinycolor from 'tinycolor2';
+
+const DEFAULT_NUM_DARK_COLORS = 4;
+const DEFAULT_NUM_LIGHT_COLORS = 4;
+const errorColor = tinycolor('#ffffffff');
+const CONTRAST_RANGE = [
+    '#111111',
+    '#FEFEFE'
+];
+const mix = (startColor, mixinColor, weight)=>{
+    if (!mixinColor || !mixinColor.isValid()) {
+        throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
+    }
+    const color1 = mixinColor;
+    const p = weight === undefined ? 0.5 : weight;
+    const w = 2 * p - 1;
+    const a = color1.getAlpha() - startColor.getAlpha();
+    const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2;
+    const w2 = 1 - w1;
+    return tinycolor.fromRatio({
+        r: w1 * color1.toRgb().r + w2 * startColor.toRgb().r,
+        g: w1 * color1.toRgb().g + w2 * startColor.toRgb().g,
+        b: w1 * color1.toRgb().b + w2 * startColor.toRgb().b,
+        a: color1.getAlpha() * p + startColor.getAlpha() * (1 - p)
+    });
+};
+const getColorsList = (colorsAmount, colorsShiftAmount, mixColor, saturation, mainColor)=>{
+    const colorsList = [];
+    const givenColor = mainColor.isValid() ? mainColor : errorColor;
+    let step;
+    for(step = 0; step < colorsAmount; step++){
+        if (mainColor.isValid()) {
+            colorsList.push(mix(givenColor.saturate((step + 1) / colorsAmount * (saturation / 100)), mixColor, colorsShiftAmount / 100 * (step + 1) / colorsAmount));
+        } else {
+            colorsList.push(errorColor);
+        }
+    }
+    return colorsList;
+};
+const colorType = [
+    'min',
+    'darkest',
+    'darker',
+    'dark',
+    'DEFAULT',
+    'vivid',
+    'light',
+    'lighter',
+    'lightest',
+    'max'
+];
+const create10ColorPallet = (mainColor)=>{
+    const darkColors = getColorsList(DEFAULT_NUM_DARK_COLORS, 90, tinycolor('#000000'), 20, tinycolor(mainColor)).map((color)=>color);
+    const lightColors = getColorsList(DEFAULT_NUM_LIGHT_COLORS, 90, tinycolor('#ffffff'), 20, tinycolor(mainColor)).reverse().map((color)=>color);
+    return {
+        ...lightColors.reduce((obj, c, idx)=>{
+            obj[colorType[9 - idx]] = c.toHexString();
+            return obj;
+        }, {}),
+        DEFAULT: mainColor,
+        vivid: tinycolor(mainColor).saturate(10).toHexString(),
+        ...darkColors.reduce((obj, c, idx)=>{
+            obj[colorType[3 - idx]] = c.toHexString();
+            return obj;
+        }, {})
+    };
+};
+const create10ColorAccessibleContrast = (pallet)=>{
+    return Object.entries(pallet).reduce((results, [colorName, value])=>{
+        return {
+            ...results,
+            [colorName]: tinycolor.mostReadable(value, CONTRAST_RANGE, {
+                includeFallbackColors: true,
+                level: 'AAA',
+                size: 'large'
+            }).toHexString()
+        };
+    }, {});
+};
+
+const utility = {
+    link: '#155276',
+    success: '#318f71',
+    warning: '#d9a214',
+    error: '#8a0e2a',
+    emergency: '#6a0019',
+    info: '#1c5e86',
+    category1: '#1c5e86',
+    category2: '#d1541d',
+    category3: '#564990',
+    category4: '#4dbc97'
+};
+const utilityContrast = {
+    link: '#f1f1f1',
+    success: '#000000',
+    warning: '#1b1b1b',
+    error: '#f1f1f1',
+    emergency: '#f1f1f1',
+    info: '#f1f1f1',
+    category1: '#f1f1f1',
+    category2: '#000000',
+    category3: '#f1f1f1',
+    category4: '#1b1b1b'
+};
+const main = ()=>{
+    const { values: { themeFile, out } } = parseArgs({
+        options: {
+            themeFile: {
+                type: 'string',
+                short: 't',
+                default: './colors.json'
+            },
+            primary: {
+                type: 'string',
+                short: 'p',
+                default: '#532565'
+            },
+            secondary: {
+                type: 'string',
+                short: 's',
+                default: '#982568'
+            },
+            accent: {
+                type: 'string',
+                short: 'a',
+                default: '#E07C3E'
+            },
+            accentWarm: {
+                type: 'string',
+                default: '#E07C3E'
+            },
+            accentCool: {
+                type: 'string',
+                default: '#1552e0'
+            },
+            base: {
+                type: 'string',
+                short: 'b',
+                default: '#858585'
+            },
+            table: {
+                type: 'string',
+                short: 'b',
+                default: '#858585'
+            },
+            out: {
+                type: 'string',
+                short: 'o',
+                default: '../'
+            }
+        }
+    });
+    if (!themeFile) {
+        console.log('No themefile found. Please provide a themefile with \'-t\'.');
+        return;
+    }
+    if (themeFile && !existsSync(themeFile)) {
+        console.log('No themefile found. Please provide a themefile with \'-t\'.');
+        return;
+    }
+    const themeData = readFileSync(themeFile, {
+        encoding: 'utf8',
+        flag: 'r'
+    });
+    const themeColors = JSON.parse(themeData);
+    const primaryPallet = create10ColorPallet(themeColors.primary);
+    const secondaryPallet = create10ColorPallet(themeColors.secondary);
+    const accentPallet = create10ColorPallet(themeColors.accent);
+    const accentPalletWarm = create10ColorPallet(themeColors.accentWarm);
+    const accentPalletCool = create10ColorPallet(themeColors.accentCool);
+    const basePallet = create10ColorPallet(themeColors.base);
+    const chartPallet = create10ColorPallet(themeColors.chart);
+    const tablePallet = create10ColorPallet(themeColors?.table ?? '#ffffff');
+    const theme = {
+        primary: primaryPallet,
+        'primary-contrast': create10ColorAccessibleContrast(primaryPallet),
+        secondary: secondaryPallet,
+        'secondary-contrast': create10ColorAccessibleContrast(secondaryPallet),
+        accent: accentPallet,
+        'accent-contrast': create10ColorAccessibleContrast(accentPallet),
+        'accent-warm': accentPalletWarm,
+        'accent-warm-contrast': create10ColorAccessibleContrast(accentPalletWarm),
+        'accent-cool': accentPalletCool,
+        'accent-cool-contrast': create10ColorAccessibleContrast(accentPalletCool),
+        base: basePallet,
+        'base-contrast': create10ColorAccessibleContrast(basePallet),
+        utility: utility,
+        'utility-contrast': utilityContrast,
+        chart: chartPallet,
+        'chart-contrast': create10ColorAccessibleContrast(chartPallet),
+        table: tablePallet,
+        'table-contrast': create10ColorAccessibleContrast(tablePallet)
+    };
+    writeFileSync(join(out ?? './', 'themeColors.json'), JSON.stringify(theme, null, 2));
+};
+main();

package/dist/bundleIcons.esm.js

@@ -0,0 +1,70 @@
+import { promises } from 'fs';
+import { importDirectory } from '@iconify/tools/lib/import/directory';
+import { cleanupSVG } from '@iconify/tools/lib/svg/cleanup';
+import { runSVGO } from '@iconify/tools/lib/optimise/svgo';
+import { parseColors, isEmptyColor } from '@iconify/tools/lib/colors/parse';
+
+const getArgs = (defaults = {})=>{
+    const args = defaults;
+    process.argv.slice(2, process.argv.length).forEach((arg)=>{
+        // long arg
+        if (arg.slice(0, 2) === '--') {
+            const longArg = arg.split('=');
+            const longArgFlag = longArg[0].slice(2, longArg[0].length);
+            const longArgValue = longArg.length > 1 ? longArg[1] : true;
+            args[longArgFlag] = longArgValue;
+        } else if (arg[0] === '-') {
+            const flags = arg.slice(1, arg.length).split('');
+            flags.forEach((flag)=>{
+                args[flag] = true;
+            });
+        }
+    });
+    return args;
+};
+const build = async (inpath, outpath, prefix = 'gen3')=>{
+    // Import icons
+    console.log(inpath, outpath, prefix);
+    const iconSet = await importDirectory(inpath, {
+        prefix: prefix,
+        includeSubDirs: true
+    });
+    // Validate, clean up, fix palette and optimise
+    await iconSet.forEach(async (name, type)=>{
+        if (type !== 'icon') {
+            return;
+        }
+        const svg = iconSet.toSVG(name);
+        if (!svg) {
+            // Invalid icon
+            iconSet.remove(name);
+            return;
+        }
+        // Clean up and optimise icons
+        try {
+            await cleanupSVG(svg);
+            await parseColors(svg, {
+                defaultColor: 'currentColor',
+                callback: (attr, colorStr, color)=>{
+                    return !color || isEmptyColor(color) ? colorStr : 'currentColor';
+                }
+            });
+            await runSVGO(svg);
+        } catch (err) {
+            // Invalid icon
+            console.error(`Error parsing ${name}:`, err);
+            iconSet.remove(name);
+            return;
+        }
+        // Update icon
+        iconSet.fromSVG(name, svg);
+    });
+    // Export as IconifyJSON
+    const exported = JSON.stringify(iconSet.export(), null, '\t') + '\n';
+    // Save to file
+    await promises.writeFile(`${outpath}/${iconSet.prefix}.json`, exported, 'utf8');
+};
+const { inpath, outpath, prefix } = getArgs({
+    prefix: 'gen3'
+});
+build(inpath, outpath, prefix);

package/dist/getDRSToHostname.esm.js

@@ -0,0 +1,67 @@
+import { Agent as Agent$1 } from 'https';
+import { Agent } from 'http';
+import { writeFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+import fetchRetry from 'fetch-retry';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fetchWithRetry = fetchRetry(fetch);
+const httpAgent = new Agent();
+const httpsAgent = new Agent$1({
+    rejectUnauthorized: false
+});
+const fetchJson = async (url)=>{
+    console.log(`Fetching DRS ids from ${url}`);
+    return fetchWithRetry(url, {
+        // TODO: fix the typing to remove the ignore
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        agent: url.match(/^https:/) ? httpsAgent : httpAgent,
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        },
+        retries: 5,
+        retryDelay: 800
+    }).then((res)=>{
+        if (res.status === 200) {
+            return res.json().catch((err)=>console.error(`failed json parse - ${err}`));
+        }
+    });
+};
+const main = ()=>{
+    let drsResolverURL = 'https://dataguids.org';
+    if (process.env.DRS_RESOLVER_URL) {
+        drsResolverURL = process.env.DRS_RESOLVER_URL;
+    }
+    const { values: { out } } = parseArgs({
+        options: {
+            out: {
+                type: 'string',
+                short: 'o',
+                default: `${__dirname}`
+            }
+        }
+    });
+    const drsCachePath = `${out}/drsHostnames.json`;
+    fetchJson(`${drsResolverURL}/index/_dist`).then((drsIds)=>{
+        if (!drsIds) {
+            throw new Error('Failed to fetch drsHostnames.json');
+        }
+        const drsCache = drsIds.reduce((acc, drsId)=>{
+            const ids = drsId.hints.map((hint)=>hint.replace('.*', '').replace('.*', '').replace('\\.', '.'));
+            ids.forEach((id)=>{
+                acc[id] = drsId.host.replace('https://', '').replace('/index/', '');
+            });
+            return acc;
+        }, {});
+        writeFileSync(drsCachePath, JSON.stringify(drsCache, null, 2));
+    });
+};
+main();
+
+export { main as default };

package/dist/getSchema.esm.js

@@ -0,0 +1,124 @@
+import { Agent as Agent$1 } from 'https';
+import { Agent } from 'http';
+import { buildClientSchema, printSchema } from 'graphql';
+import { writeFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+import fetchRetry from 'fetch-retry';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fetchWithRetry = fetchRetry(fetch);
+const getSubPath = (argPath = '')=>{
+    const addSlash = (path)=>`${path}/`.replace(/\/+$/, '/');
+    if (!argPath) {
+        let commonsDefaultPath = 'http://localhost:5000/v0/submission/';
+        if (process.env.HOSTNAME) {
+            commonsDefaultPath = `https://${process.env.HOSTNAME}/api/v0/submission/`;
+            if (process.env.HOSTNAME.startsWith('revproxy')) {
+                // running thur a revproxy like nginx
+                commonsDefaultPath = `http://${process.env.HOSTNAME}/api/v0/submission/`;
+            }
+        }
+        return {
+            valid: 'ok',
+            commonsSubPath: addSlash(process.env.GEN3_SUBMISSION_URL || commonsDefaultPath)
+        };
+    }
+    const arg1 = argPath;
+    if (!arg1.match(/^https?:\/\//)) {
+        console.log(`
+    getSchema downloads data/schema.json and data/dictionary.json from the environment's
+    gen-api for later use configuring gql queries
+
+    Use: node getSchema.js [submissionApiPath]
+        - where gdcSubmissionApiPath defaults to: process.env.GEN3_SUBPATH || 'http://localhost:5000/v0/submission/'
+        - example - if gdcSubmissionApiPath = https://dev.bionimbus.org/api/vo/submission/,
+            then the script loads:
+            * https://dev.bionimbus.org/api/v0/submission/_dictionary/_all
+            * https://dev.bionimbus.org/api/v0/submission/getschema
+    `);
+        return {
+            valid: 'exit'
+        };
+    }
+    return {
+        valid: 'ok',
+        commonsSubPath: addSlash(arg1)
+    };
+};
+const httpAgent = new Agent();
+const httpsAgent = new Agent$1({
+    rejectUnauthorized: false
+});
+const fetchJson = async (url)=>{
+    console.log(`Fetching ${url}`);
+    return fetchWithRetry(url, {
+        // TODO: fix the typing to remove the ts-ignore
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        agent: url.match(/^https:/) ? httpsAgent : httpAgent,
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        },
+        retries: 5,
+        retryDelay: 800
+    }).then((res)=>{
+        if (res.status === 200) {
+            return res.json().catch((err)=>console.error(`failed json parse - ${err}`));
+        }
+    });
+};
+const main = ()=>{
+    const { values: { url, out } } = parseArgs({
+        options: {
+            url: {
+                type: 'string',
+                default: undefined
+            },
+            out: {
+                type: 'string',
+                short: 'o',
+                default: `${__dirname}`
+            }
+        }
+    });
+    const { valid, commonsSubPath } = getSubPath(url);
+    if (valid !== 'ok') {
+        process.exit(1);
+    }
+    const schemaUrl = `${commonsSubPath}getschema`;
+    const schemaPath = `${out}/schema.json`;
+    const dictUrl = `${commonsSubPath}_dictionary/_all`;
+    const dictPath = `${out}/dictionary.json`;
+    const actionList = [];
+    actionList.push(// Save JSON of full schema introspection for Babel Relay Plugin to use
+    fetchJson(schemaUrl).then((schema)=>{
+        if (!schema) {
+            throw new Error('Failed to fetch schema.json');
+        }
+        writeFileSync(schemaPath, JSON.stringify(schema, null, 2));
+        // Save user readable type system shorthand of schema
+        const graphQLSchema = buildClientSchema(schema.data);
+        writeFileSync(`${__dirname}/schema.graphql`, printSchema(graphQLSchema));
+    }));
+    actionList.push(fetchJson(dictUrl).then((dict)=>{
+        if (!dict) {
+            throw new Error('Failed to fetch dictionary.json');
+        }
+        writeFileSync(dictPath, JSON.stringify(dict, null, 2));
+    }));
+    Promise.all(actionList).then(()=>{
+        console.log('All done!');
+        process.exit(0);
+    }, (err)=>{
+        console.error('Error: ', err);
+        process.exit(2);
+    });
+};
+main();
+
+export { main as default };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@gen3/toolsff",
+  "version": "0.10.44",
+  "description": "tools for processing portal content",
+  "main": "index.js",
+  "type": "module",
+  "engines": {
+    "npm": ">=10.2.3",
+    "node": ">=20.11.0"
+  },
+  "scripts": {
+    "lint": "eslint --ext .js,.ts src",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "clean": "rimraf ./dist",
+    "build": "rollup --config rollup.config.js",
+    "build:clean": "npm run clean && npm run build"
+  },
+  "bin": {
+    "buildColors": "./dist/buildColors.esm.js",
+    "bundleIcons": "./dist/bundleIcons.esm.js",
+    "getSchema": "./dist/getSchema.esm.js",
+    "getDRSToHostname": "./dist/getDRSToHostname.esm.js"
+  },
+  "author": "Craig Barnes",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@iconify/tools": "^2.1.2",
+    "tinycolor2": "^1.6.0"
+  },
+  "devDependencies": {
+    "rollup-plugin-executable": "^1.6.3"
+  },
+  "peerDependencies": {
+    "ts-node": "^10.9.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "gitHead": "4fa5483ea0d4d9d1e7b861ce0763490afd799e26"
+}