feat(flutter): create package

.github/workflows/release.yaml

@@ -10,36 +10,40 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-      with:
-        ref: master # We have to checkout master or PNPM fails. Tag should be on master anyway.
-    - uses: actions/cache@v2
-      with:
-        path: ~/.pnpm-store
-        key: ${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
-        restore-keys: |
-          ${{ runner.os }}-
-    - uses: actions/setup-node@v2
-      with:
-        node-version: '14'
-        registry-url: 'https://registry.npmjs.org'
-    - uses: pnpm/action-setup@v2.1.0
-      with:
-        version: 6.27.1
-        run_install: true
-    - run: pnpm run build
-    - run: pnpm run prepublish-all
-      env:
-        TAG_NAME: ${{ github.ref_name }}
-    - uses: stefanzweifel/git-auto-commit-action@v4
-      with:
-        commit_message: Release Version ${{ github.ref_name }}
-        branch: master
-    - run: git -c user.email="actions@github.com" -c user.name="GitHub Actions" tag -fa ${{ github.ref_name }} -m "${{ github.ref_name }}"
-    - run: git push -f origin ${{ github.ref_name }}
-    - run: npm publish --access public
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-    - run: pnpm -r publish --filter ./packages --access public
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - uses: actions/checkout@v2
+        with:
+          ref: master # We have to checkout master or PNPM fails. Tag should be on master anyway.
+      - uses: actions/cache@v2
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+          registry-url: 'https://registry.npmjs.org'
+      - uses: pnpm/action-setup@v2.1.0
+        with:
+          version: 6.27.1
+          run_install: true
+      - run: pnpm run build
+      - run: pnpm run prepublish-all
+        env:
+          TAG_NAME: ${{ github.ref_name }}
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: Release Version ${{ github.ref_name }}
+          branch: master
+      - run: git -c user.email="actions@github.com" -c user.name="GitHub Actions" tag -fa ${{ github.ref_name }} -m "${{ github.ref_name }}"
+      - run: git push -f origin ${{ github.ref_name }}
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: pnpm -r publish --filter ./packages --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - uses: sakebook/actions-flutter-pub-publisher@v1
+        with:
+          credential: ${{ secrets.PUB_CREDENTIAL_JSON }}
+          package_directory: ./packages/iconoir-flutter

analysis_options.yaml

@@ -0,0 +1,2 @@
+analyzer:
+  exclude: [bin/templates/**]

bin/build.js

@@ -1,10 +1,10 @@
-import path from 'path';
-import os from 'os';
-import { promises as fs, readFileSync } from 'fs';
 import execa from 'execa';
+import { promises as fs, readFileSync } from 'fs';
+import { generateTemplateFilesBatch } from 'generate-template-files';
 import { Listr } from 'listr2';
+import os from 'os';
+import path, { basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 
 // Paths
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -29,6 +29,7 @@ const incompatibleNames = {
 const targets = {
   'meta-data': { path: 'meta-data.json' },
   css: { path: 'css/iconoir.css' },
+  'iconoir-flutter': { flutter: true, path: 'packages/iconoir-flutter' },
   'iconoir-react': { react: true, path: 'packages/iconoir-react' },
   'iconoir-react-native': {
     react: true,
@@ -250,11 +251,204 @@ const tasks = new Listr(
                         });
                       },
                     },
+                  ],
+                  { concurrent: false }
+                ),
+            },
+            {
+              title: 'Building Flutter libraries',
+              enabled: () =>
+                cliTargets.length === 0 ||
+                cliTargets.filter((cliTarget) => targets[cliTarget]?.flutter)
+                  .length > 0,
+              task: (_, task) =>
+                task.newListr(
+                  [
                     {
-                      title: 'Removing temporary directory',
-                      skip: (ctx) => !ctx.tmpDir,
+                      title: 'Creating temporary directory',
                       task: async (ctx) => {
-                        await fs.rm(ctx.tmpDir, { recursive: true });
+                        try {
+                          ctx.tmpDir = await fs.mkdtemp(
+                            path.join(os.tmpdir(), 'iconoir-')
+                          );
+                        } catch (err) {
+                          ctx.skip = true;
+                          throw new Error(err.message);
+                        }
+                      },
+                    },
+                    {
+                      title:
+                        'Copying icon files to temporary directory, while renaming icons with incompatible names',
+                      skip: (ctx) => ctx.skip,
+                      task: async (ctx) => {
+                        try {
+                          const promises = ctx.iconoirIconsFiles.map((file) => {
+                            const srcFilePath = path.join(
+                              iconoirIconsDir,
+                              file
+                            );
+                            const iconName = file.split('.')[0];
+                            const dstFileName =
+                              iconName in incompatibleNames
+                                ? incompatibleNames[iconName]
+                                : iconName;
+                            const dstFilePath = path.join(
+                              ctx.tmpDir,
+                              `${dstFileName}.svg`
+                            );
+
+                            ctx.dstFilePaths = [
+                              ...(ctx.dstFilePaths ?? []),
+                              dstFilePath,
+                            ];
+
+                            return fs.copyFile(srcFilePath, dstFilePath);
+                          });
+                          return Promise.all(promises).catch((err) => {
+                            ctx.skip = true;
+                            throw new Error(err.message);
+                          });
+                        } catch (err) {
+                          ctx.skip = true;
+                          throw new Error(err.message);
+                        }
+                      },
+                    },
+                    {
+                      skip: (ctx) => ctx.skip,
+                      task: (_, task) => {
+                        const targetsToBuild =
+                          cliTargets.length > 0
+                            ? cliTargets.filter(
+                                (cliTarget) => targets[cliTarget]?.flutter
+                              )
+                            : Object.keys(targets).filter(
+                                (target) => targets[target].flutter
+                              );
+                        const tasks = targetsToBuild.map((target) => {
+                          const builtIconsDir = path.join(
+                            rootDir,
+                            targets[target].path,
+                            'lib'
+                          );
+                          return {
+                            title: `Building ${target}`,
+                            task: (_, task) =>
+                              task.newListr(
+                                [
+                                  {
+                                    title: 'Cleaning target directory',
+                                    task: async (ctx) => {
+                                      try {
+                                        const files = await fs.readdir(
+                                          builtIconsDir
+                                        );
+                                        const promises = files.map((file) => {
+                                          return fs.unlink(
+                                            path.join(builtIconsDir, file)
+                                          );
+                                        });
+                                        return Promise.all(promises).catch(
+                                          (err) => {
+                                            ctx[target] = { skip: true };
+                                            throw new Error(err.message);
+                                          }
+                                        );
+                                      } catch (err) {
+                                        ctx[target] = { skip: true };
+                                        throw new Error(err.message);
+                                      }
+                                    },
+                                  },
+                                  {
+                                    title: 'Create entry file',
+                                    task: async () => {
+                                      await fs.writeFile(
+                                        path.join(
+                                          builtIconsDir,
+                                          'iconoir_flutter.dart'
+                                        ),
+                                        'library iconoir_flutter;\n\n'
+                                      );
+                                    },
+                                  },
+                                  {
+                                    title: 'Building icon files',
+                                    skip: (ctx) => ctx[target]?.skip,
+                                    task: async (ctx) => {
+                                      try {
+                                        ctx.dstFilePaths.forEach(
+                                          async (file) => {
+                                            const svgfilename =
+                                              path.parse(file).name;
+                                            // Prefix with Svg if icon name starts with a number
+                                            const iconname = `${
+                                              /^\d/.test(svgfilename)
+                                                ? 'Svg'
+                                                : ''
+                                            }${svgfilename}`;
+
+                                            const svgfilecontent = (
+                                              await fs.readFile(file)
+                                            ).toString();
+
+                                            await generateTemplateFilesBatch([
+                                              {
+                                                option:
+                                                  'Create Icon Flutter Widget',
+                                                entry: {
+                                                  folderPath:
+                                                    './bin/templates/__svgfilename__.dart',
+                                                },
+                                                dynamicReplacers: [
+                                                  {
+                                                    slot: '__icon__',
+                                                    slotValue: iconname,
+                                                  },
+                                                  {
+                                                    slot: '__svgfilecontent__',
+                                                    slotValue: svgfilecontent,
+                                                  },
+                                                  {
+                                                    slot: '__svgfilename__',
+                                                    slotValue: svgfilename,
+                                                  },
+                                                ],
+                                                output: {
+                                                  path: './packages/iconoir-flutter/lib/__svgfilename__(snakeCase).dart',
+                                                  pathAndFileNameDefaultCase:
+                                                    '(snakeCase)',
+                                                },
+                                                async onComplete(results) {
+                                                  await fs.appendFile(
+                                                    path.join(
+                                                      builtIconsDir,
+                                                      'iconoir_flutter.dart'
+                                                    ),
+                                                    `export './${basename(
+                                                      results.output.path
+                                                    )}';\n`
+                                                  );
+                                                },
+                                              },
+                                            ]);
+                                          }
+                                        );
+                                      } catch (err) {
+                                        throw new Error(err.message);
+                                      }
+                                    },
+                                  },
+                                ],
+                                { concurrent: false, exitOnError: false }
+                              ),
+                          };
+                        });
+                        return task.newListr(tasks, {
+                          concurrent: true,
+                          rendererOptions: { collapse: false },
+                        });
                       },
                     },
                   ],
@@ -265,6 +459,13 @@ const tasks = new Listr(
           { concurrent: true }
         ),
     },
+    {
+      title: 'Removing temporary directory',
+      skip: (ctx) => !ctx.tmpDir,
+      task: async (ctx) => {
+        await fs.rm(ctx.tmpDir, { recursive: true });
+      },
+    },
   ],
   {
     concurrent: false,

bin/prepublish.js

@@ -1,17 +1,18 @@
-import semver from 'semver';
-import path from 'path';
+import { updateYamlKey } from '@atomist/yaml-updater';
 import fs from 'fs';
+import path from 'path';
+import semver from 'semver';
 
 const PACKAGE_BASE = '';
 
-function publishPackage(name) {
-  console.info('Publishing %s', name);
+const newVersion = semver.valid(semver.coerce(process.env.TAG_NAME));
+console.info('New version is %s', newVersion);
+if (!newVersion) {
+  throw new Error(`Tag name ${process.env.TAG_NAME} is not valid.`);
+}
 
-  const newVersion = semver.valid(semver.coerce(process.env.TAG_NAME));
-  console.info('New version is %s', newVersion);
-  if (!newVersion) {
-    throw new Error(`Tag name ${process.env.TAG_NAME} is not valid.`);
-  }
+function publishNpmPackage(name) {
+  console.info('Publishing %s', name);
 
   const packageJsonPath =
     name === 'iconoir'
@@ -26,6 +27,19 @@ function publishPackage(name) {
   console.info('package.json updated');
 }
 
-publishPackage('iconoir');
-publishPackage('iconoir-react');
-publishPackage('iconoir-react-native');
+function publishPubPackage(name) {
+  const pubspecFilepath = path.join('packages', name, 'pubspec.yaml');
+  const pubspecContents = fs.readFileSync(pubspecFilepath).toString();
+
+  fs.writeFileSync(
+    pubspecFilepath,
+    updateYamlKey('version', newVersion, pubspecContents)
+  );
+
+  console.info('pubspec.yaml updated');
+}
+
+publishNpmPackage('iconoir');
+publishNpmPackage('iconoir-react');
+publishNpmPackage('iconoir-react-native');
+publishPubPackage('iconoir-flutter');

bin/templates/__svgfilename__.dart

@@ -0,0 +1,20 @@
+import 'package:flutter/widgets.dart';
+import 'package:flutter_svg/flutter_svg.dart';
+
+class __icon__(pascalCase) extends StatelessWidget {
+  final Color? color;
+  final double? width;
+  final double? height;
+
+  const __icon__(pascalCase)({Key? key, this.color, this.width, this.height})
+      : super(key: key);
+
+  @override
+  Widget build(BuildContext context) => SvgPicture.string(
+        '''
+__svgfilecontent__''',
+        color: color,
+        width: width,
+        height: height,
+      );
+}