@medely/fontawesome-svg-core 0.0.1 → 0.1.0

package/LICENSE.txt

@@ -23,7 +23,7 @@ as SVG and JS file types.
 In the Font Awesome Free download, the SIL OFL license applies to all icons
 packaged as web and desktop font files.
 
-Copyright (c) 2023 Fonticons, Inc. (https://fontawesome.com)
+Copyright (c) 2024 Fonticons, Inc. (https://fontawesome.com)
 with Reserved Font Name: "Font Awesome".
 
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
@@ -123,7 +123,7 @@ OTHER DEALINGS IN THE FONT SOFTWARE.
 In the Font Awesome Free download, the MIT license applies to all non-font and
 non-icon files.
 
-Copyright 2023 Fonticons, Inc.
+Copyright 2024 Fonticons, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in the

package/README.md

@@ -1,26 +1,26 @@
-# ../fontawesome-svg-core - SVG with JavaScript version
+# @fortawesome/fontawesome-svg-core - SVG with JavaScript version
 
 > "I came here to chew bubblegum and install Font Awesome 6 - and I'm all out of bubblegum"
 
-[![npm](https://img.shields.io/npm/v/../fontawesome-svg-core.svg?style=flat-square)](https://www.npmjs.com/package/../fontawesome-svg-core)
+[![npm](https://img.shields.io/npm/v/@fortawesome/fontawesome-svg-core.svg?style=flat-square)](https://www.npmjs.com/package/@fortawesome/fontawesome-svg-core)
 
 ## Installation
 
 ```
-$ npm i --save ../fontawesome-svg-core
+$ npm i --save @fortawesome/fontawesome-svg-core
 ```
 
 Or
 
 ```
-$ yarn add ../fontawesome-svg-core
+$ yarn add @fortawesome/fontawesome-svg-core
 ```
 
 ## Documentation
 
-Get started [here](https://fontawesome.com/how-to-use/on-the-web/setup/getting-started). Continue your journey [here](https://fontawesome.com/how-to-use/on-the-web/advanced).
+Get started [here](https://docs.fontawesome.com/web/setup/get-started). Continue your journey [here](https://docs.fontawesome.com/web/setup/packages).
 
-Or go straight to the [API documentation](https://fontawesome.com/how-to-use/with-the-api).
+Or go straight to the [API documentation](https://docs.fontawesome.com/apis/javascript/get-started).
 
 ## Issues and support
 

package/import.macro.d.ts

@@ -3,7 +3,7 @@ import {
     IconName,
     IconStyle,
     IconFamily
-} from '../fontawesome-common-types';
+} from '@fortawesome/fontawesome-common-types';
 
 export type IconMacroParams = {
     name: IconName,

package/import.macro.js

@@ -1,21 +1,23 @@
-const { createMacro, MacroError } = require('babel-plugin-macros');
-const { addNamed } = require('@babel/helper-module-imports');
+const { createMacro, MacroError } = require('babel-plugin-macros')
+const { addNamed } = require('@babel/helper-module-imports')
+const { FAFamilyIds, FAFamilyClassicId, FAFamilyDuotoneId } = require('@fortawesome-internal-tools/fontawesome-icons/canonical')
+const { FALegacyStyleIds } = require('@fortawesome-internal-tools/fontawesome-icons/legacy')
 
 module.exports = createMacro(importer, {
-  configName: 'fontawesome-svg-core',
-});
+  configName: 'fontawesome-svg-core'
+})
 
-const styles = ['solid', 'regular', 'light', 'thin', 'duotone', 'brands'];
+const styles = FALegacyStyleIds
 
-const macroNames = [...styles, 'icon'];
+const macroNames = [...styles, 'icon']
 
-const families = ['classic', 'duotone', 'sharp'];
+const families = FAFamilyIds.map((family) => family.toLowerCase())
 
 function importer({ references, state, babel, source, config }) {
-  const license = config !== undefined ? config.license : 'free';
+  const license = config !== undefined ? config.license : 'free'
 
   if (!['free', 'pro'].includes(license)) {
-    throw new Error("config license must be either 'free' or 'pro'");
+    throw new Error("config license must be either 'free' or 'pro'")
   }
 
   Object.keys(references).forEach((key) => {
@@ -25,67 +27,58 @@ function importer({ references, state, babel, source, config }) {
       references: references[key],
       state,
       babel,
-      source,
-    });
-  });
+      source
+    })
+  })
 }
 
 function replace({ macroName, license, references, state, babel, source }) {
   references.forEach((nodePath) => {
-    const { iconName, style, family } = resolveReplacement({ nodePath, babel, state, macroName });
+    const { iconName, style, family } = resolveReplacement({ nodePath, babel, state, macroName })
 
-    const name = `fa${capitalize(camelCase(iconName))}`;
-    const importFrom = getImport({ family, style, license, name });
+    const name = `fa${capitalize(camelCase(iconName))}`
+    const importFrom = getImport({ family, style, license, name })
 
-    const importName = addNamed(nodePath, name, importFrom);
+    const importName = addNamed(nodePath, name, importFrom)
 
-    nodePath.parentPath.replaceWith(importName);
-  });
+    nodePath.parentPath.replaceWith(importName)
+  })
 }
 
 function getImport({ family, style, license, name }) {
   if (family) {
-    return `../${family.toLowerCase()}-${style}-svg-icons/${name}`;
+    return `@fortawesome/${family.toLowerCase()}-${style}-svg-icons/${name}`
   } else if (style === 'brands') {
-    return `../free-brands-svg-icons/${name}`;
+    return `@fortawesome/free-brands-svg-icons/${name}`
   } else {
-    return `../${license}-${style}-svg-icons/${name}`;
+    return `@fortawesome/${license}-${style}-svg-icons/${name}`
   }
 }
 
 function resolveReplacement({ nodePath, babel, state, macroName }) {
   if ('icon' === macroName) {
-    return resolveReplacementIcon({ nodePath, babel, state, macroName });
+    return resolveReplacementIcon({ nodePath, babel, state, macroName })
   } else {
-    return resolveReplacementLegacyStyle({ nodePath, babel, state, macroName });
+    return resolveReplacementLegacyStyle({ nodePath, babel, state, macroName })
   }
 }
 
 // The macros corresonding to legacy style names: solid(), regular(), light(), thin(), duotone(), brands().
 function resolveReplacementLegacyStyle({ nodePath, babel, state, macroName }) {
-  const { types: t } = babel;
-  const { parentPath } = nodePath;
+  const { types: t } = babel
+  const { parentPath } = nodePath
 
   if (!styles.includes(macroName)) {
-    throw parentPath.buildCodeFrameError(
-      `${macroName} is not a valid macro name. Use one of ${macroNames.join(', ')}`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`${macroName} is not a valid macro name. Use one of ${macroNames.join(', ')}`, MacroError)
   }
 
   if (parentPath.node.arguments) {
     if (parentPath.node.arguments.length < 1) {
-      throw parentPath.buildCodeFrameError(
-        `Received an invalid number of arguments for ${macroName} macro: must be exactly 1`,
-        MacroError,
-      );
+      throw parentPath.buildCodeFrameError(`Received an invalid number of arguments for ${macroName} macro: must be exactly 1`, MacroError)
     }
 
     if (parentPath.node.arguments.length > 1) {
-      throw parentPath.buildCodeFrameError(
-        `Received an invalid number of arguments for ${macroName} macro: must be exactly 1`,
-        MacroError,
-      );
+      throw parentPath.buildCodeFrameError(`Received an invalid number of arguments for ${macroName} macro: must be exactly 1`, MacroError)
     }
 
     if (
@@ -93,209 +86,135 @@ function resolveReplacementLegacyStyle({ nodePath, babel, state, macroName }) {
       t.isStringLiteral(parentPath.node.arguments[0]) &&
       nodePath.parentPath.node.arguments[0].value.startsWith('fa-')
     ) {
-      throw parentPath.buildCodeFrameError(
-        `Don't begin the icon name with fa-, just use ${nodePath.parentPath.node.arguments[0].value.slice(
-          3,
-        )}`,
-        MacroError,
-      );
+      throw parentPath.buildCodeFrameError(`Don't begin the icon name with fa-, just use ${nodePath.parentPath.node.arguments[0].value.slice(3)}`, MacroError)
     }
 
-    if (
-      (parentPath.node.arguments.length === 1 || parentPath.node.arguments.length === 2) &&
-      !t.isStringLiteral(parentPath.node.arguments[0])
-    ) {
-      throw parentPath.buildCodeFrameError(
-        'Only string literals are supported when referencing icons (use a string here instead)',
-        MacroError,
-      );
+    if ((parentPath.node.arguments.length === 1 || parentPath.node.arguments.length === 2) && !t.isStringLiteral(parentPath.node.arguments[0])) {
+      throw parentPath.buildCodeFrameError('Only string literals are supported when referencing icons (use a string here instead)', MacroError)
     }
   } else {
-    throw parentPath.buildCodeFrameError(
-      'Pass the icon name you would like to import as an argument.',
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError('Pass the icon name you would like to import as an argument.', MacroError)
   }
 
   return {
     iconName: nodePath.parentPath.node.arguments[0].value,
     style: macroName,
-    family: undefined,
-  };
+    family: undefined
+  }
 }
 
 // The icon() macro.
 function resolveReplacementIcon({ nodePath, babel, state, macroName }) {
-  const { types: t } = babel;
-  const { parentPath } = nodePath;
+  const { types: t } = babel
+  const { parentPath } = nodePath
 
   if ('icon' !== macroName) {
-    throw parentPath.buildCodeFrameError(
-      `${macroName} is not a valid macro name. Use one of ${macroNames.join(', ')}`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`${macroName} is not a valid macro name. Use one of ${macroNames.join(', ')}`, MacroError)
   }
 
   if (parentPath.node.arguments.length !== 1) {
-    throw parentPath.buildCodeFrameError(
-      `Received an invalid number of arguments for ${macroName} macro: must be exactly 1`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`Received an invalid number of arguments for ${macroName} macro: must be exactly 1`, MacroError)
   }
 
   if (!t.isObjectExpression(parentPath.node.arguments[0])) {
     throw parentPath.buildCodeFrameError(
       "Only object expressions are supported when referencing icons with this macro, like this: { name: 'star' }",
-      MacroError,
-    );
+      MacroError
+    )
   }
 
-  const properties = parentPath.node.arguments[0].properties || [];
+  const properties = parentPath.node.arguments[0].properties || []
 
-  const namePropIndex = properties.findIndex((prop) => 'name' === prop.key.name);
+  const namePropIndex = properties.findIndex((prop) => 'name' === prop.key.name)
 
-  const name =
-    namePropIndex >= 0
-      ? getStringLiteralPropertyValue(
-          t,
-          parentPath,
-          parentPath.node.arguments[0].properties[namePropIndex],
-        )
-      : undefined;
+  const name = namePropIndex >= 0 ? getStringLiteralPropertyValue(t, parentPath, parentPath.node.arguments[0].properties[namePropIndex]) : undefined
 
   if (!name) {
-    throw parentPath.buildCodeFrameError(
-      'The object argument to the icon() macro must have a name property',
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError('The object argument to the icon() macro must have a name property', MacroError)
   }
 
-  const stylePropIndex = properties.findIndex((prop) => 'style' === prop.key.name);
+  const stylePropIndex = properties.findIndex((prop) => 'style' === prop.key.name)
 
-  let style =
-    stylePropIndex >= 0
-      ? getStringLiteralPropertyValue(
-          t,
-          parentPath,
-          parentPath.node.arguments[0].properties[stylePropIndex],
-        )
-      : undefined;
+  let style = stylePropIndex >= 0 ? getStringLiteralPropertyValue(t, parentPath, parentPath.node.arguments[0].properties[stylePropIndex]) : undefined
 
   if (style && !styles.includes(style)) {
-    throw parentPath.buildCodeFrameError(
-      `Invalid style name: ${style}. It must be one of the following: ${styles.join(', ')}`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`Invalid style name: ${style}. It must be one of the following: ${styles.join(', ')}`, MacroError)
   }
 
-  const familyPropIndex = properties.findIndex((prop) => 'family' === prop.key.name);
+  const familyPropIndex = properties.findIndex((prop) => 'family' === prop.key.name)
 
-  let family =
-    familyPropIndex >= 0
-      ? getStringLiteralPropertyValue(
-          t,
-          parentPath,
-          parentPath.node.arguments[0].properties[familyPropIndex],
-        )
-      : undefined;
+  let family = familyPropIndex >= 0 ? getStringLiteralPropertyValue(t, parentPath, parentPath.node.arguments[0].properties[familyPropIndex]) : undefined
 
   if (family && !families.includes(family)) {
-    throw parentPath.buildCodeFrameError(
-      `Invalid family name: ${family}. It must be one of the following: ${families.join(', ')}`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`Invalid family name: ${family}. It must be one of the following: ${families.join(', ')}`, MacroError)
   }
 
-  if ('duotone' === style && family && 'classic' !== family) {
-    throw parentPath.buildCodeFrameError(
-      `duotone cannot be used as a style name with any family other than classic`,
-      MacroError,
-    );
+  if (FAFamilyDuotoneId === style && family && FAFamilyClassicId !== family) {
+    throw parentPath.buildCodeFrameError(`duotone cannot be used as a style name with any family other than classic`, MacroError)
   }
 
-  if ('brands' === style && family && 'classic' !== family) {
-    throw parentPath.buildCodeFrameError(
-      `brands cannot be used as a style name with any family other than classic`,
-      MacroError,
-    );
+  if ('brands' === style && family && FAFamilyClassicId !== family) {
+    throw parentPath.buildCodeFrameError(`brands cannot be used as a style name with any family other than classic`, MacroError)
   }
 
   if (family && !style) {
-    throw parentPath.buildCodeFrameError(
-      `When a family is specified, a style must also be specified`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`When a family is specified, a style must also be specified`, MacroError)
   }
 
-  if ('duotone' === style || 'duotone' === family) {
-    family = undefined;
-    style = 'duotone';
+  if (FAFamilyDuotoneId === style || FAFamilyDuotoneId === family) {
+    family = undefined
+    style = FAFamilyDuotoneId
   }
 
   if ('brands' === style) {
-    family = undefined;
+    family = undefined
   }
 
   // defaults
   if (!style) {
-    style = 'solid';
+    style = 'solid'
   }
 
-  if ('classic' === family) {
-    family = undefined;
+  if (FAFamilyClassicId === family) {
+    family = undefined
   }
 
   return {
     iconName: name,
     family,
-    style,
-  };
+    style
+  }
 }
 
 function getStringLiteralPropertyValue(t, parentPath, property) {
   if (!('object' === typeof t && 'function' === typeof t.isStringLiteral)) {
-    throw Error(
-      'ERROR: invalid babel-types arg. This is probably a programming error in import.macro',
-    );
+    throw Error('ERROR: invalid babel-types arg. This is probably a programming error in import.macro')
   }
 
-  if (
-    !(
-      'object' === typeof property &&
-      'object' === typeof property.value &&
-      'object' === typeof property.key
-    )
-  ) {
-    throw Error(
-      'ERROR: invalid babel property arg. This is probably a programming error in import.macro',
-    );
+  if (!('object' === typeof property && 'object' === typeof property.value && 'object' == typeof property.key)) {
+    throw Error('ERROR: invalid babel property arg. This is probably a programming error in import.macro')
   }
 
   if (!('object' === typeof parentPath && 'function' === typeof parentPath.buildCodeFrameError)) {
-    throw Error(
-      'ERROR: invalid babel parentPath arg. This is probably a programming error in import.macro',
-    );
+    throw Error('ERROR: invalid babel parentPath arg. This is probably a programming error in import.macro')
   }
 
   if (!t.isStringLiteral(property.value)) {
-    throw parentPath.buildCodeFrameError(
-      `Only string literals are supported for the ${property.key.name} property (use a string here instead)`,
-      MacroError,
-    );
+    throw parentPath.buildCodeFrameError(`Only string literals are supported for the ${property.key.name} property (use a string here instead)`, MacroError)
   }
 
-  return property.value.value;
+  return property.value.value
 }
 
 function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1);
+  return str[0].toUpperCase() + str.slice(1)
 }
 
 function camelCase(str) {
   return str
     .split('-')
     .map((s, index) => {
-      return (index === 0 ? s[0].toLowerCase() : s[0].toUpperCase()) + s.slice(1).toLowerCase();
+      return (index === 0 ? s[0].toLowerCase() : s[0].toUpperCase()) + s.slice(1).toLowerCase()
     })
-    .join('');
+    .join('')
 }

package/index.d.ts

@@ -1,5 +1,5 @@
-import {IconDefinition, IconLookup, IconName, IconFamily, IconPrefix, CssStyleClass, IconStyle, IconPathData, IconPack} from '../fontawesome-common-types';
-export {IconDefinition, IconLookup, IconName, IconFamily, IconPrefix, CssStyleClass, IconStyle, IconPathData, IconPack} from '../fontawesome-common-types';
+import {IconDefinition, IconLookup, IconName, IconFamily, IconPrefix, CssStyleClass, IconStyle, IconPathData, IconPack} from '@fortawesome/fontawesome-common-types';
+export {IconDefinition, IconLookup, IconName, IconFamily, IconPrefix, CssStyleClass, IconStyle, IconPathData, IconPack} from '@fortawesome/fontawesome-common-types';
 export const dom: DOM;
 export const library: Library;
 export const parse: { transform(transformString: string): Transform, icon(parseIconString: string): IconLookup };
@@ -52,6 +52,7 @@ export interface Config {
   observeMutations: boolean;
   keepOriginalSource: boolean;
   measurePerformance: boolean;
+  mutateApproach: "async" | "sync";
   showMissingIcons: boolean;
 }
 export interface AbstractElement {
@@ -120,6 +121,6 @@ export interface DOM {
 }
 type IconDefinitionOrPack = IconDefinition | IconPack;
 export interface Library {
-  add(...definitions: IconDefinitionOrPack[]): void;
+  add(...definitions: Array<IconDefinitionOrPack | IconDefinitionOrPack[]>): void;
   reset(): void;
 }