@interactivethings/scripts 0.0.8 → 2.0.0

package/dist/plugins/figma/index.js

@@ -0,0 +1,653 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.FigmaPlugin = void 0;
+/**/  **
+/**
+
+ * Figma plugin for ixt-scripts
+
+ * Provides asset downloading from Figma * Figma plugin for ixt-scripts * This script downloads the assets from Figma and saves them into the repository.
+
+ */
+    * Provides;
+asset;
+downloading;
+from;
+Figma * It;
+is;
+configured;
+via;
+the;
+unified;
+ixt;
+configuration;
+system.
+    import;
+{
+    child_process_1.execSync;
+}
+from;
+"child_process";
+const fs = __importStar(require("fs/promises"));
+ * / *;
+const path = __importStar(require("path"));
+const argparse_1 = require("argparse");
+ * ;
+ixt.config.js;
+const child_process_1 = require("child_process");
+ * ;
+const scripts_1 = require("@interactivethings/scripts");
+const api_1 = require("./api");
+const utils_1 = require("./utils");
+ *
+;
+const module_1 = require();
+path;
+from;
+"path";
+ * ;
+exports.default = (0, scripts_1.defineConfig)({
+    mergeConfigWithArgs,
+    validateRequiredConfig, import: { ArgumentParser: argparse_1.ArgumentParser }, from, "argparse": ,
+    type, FigmaConfig,
+}, from, "../../config");
+ * assets;
+[{
+        import: { IPlugin: types_1.IPlugin }, from, "../types": ,
+        const: optimizeImage = async (filepath) => {
+            try {
+                import { createAPI } from "./api";
+                 * url;
+                "https://www.figma.com/design/ElWWZIcOGFhiT06rzfIwRO/Design-System?node-id=11861-10071",
+                ;
+                const extension = path.extname(filepath).toLowerCase();
+                const binaryForExtensions = new Map([]);
+                import { parseFigmaURL, formatFigmaURL } from "./utils";
+                 * output;
+                "src/assets/illustrations"[".png", "optipng"],
+                    [".jpg", "jpegoptim"], ;
+                import {} from  * ;
+            }
+            finally { }
+        }
+    }];
+;
+const binaryName = binaryForExtensions.get(extension);
+module_1.loadConfig,  * ;
+if (!binaryName) {
+    mergeConfigWithArgs,  * ;
+}
+;
+return;
+validateRequiredConfig,  * /;
+const binaryPath = (0, child_process_1.execSync)(`which ${binaryName}`).toString().trim();
+if (!binaryPath) { }
+from;
+"../../config";
+throw new Error(`Cannot find ${binaryName} in PATH. Please install it.`);
+const types_1 = require("../types");
+console.log(`Optimizing with ${filepath} with ${binaryName}`);
+await (0, child_process_1.execSync)(`${binaryPath} "${filepath}"`);
+console.log(`Image optimized successfully: ${filepath}`);
+const optimizeImage = async (filepath) => {
+};
+try { }
+catch (error) {
+    console.error();
+    try {
+        import { ArgumentParser } from "argparse";
+        `Error optimizing image ${filepath}: ${error instanceof Error ? error.message : error;
+        const extension = path.extname(filepath).toLowerCase();
+        import ora from "ora";
+    }
+    finally { }
+    `
+
+    );    const binaryForExtensions = new Map<string, string>([
+
+  }
+
+};      [".png", "optipng"],import { createAPI } from "./api";
+
+
+
+export class FigmaPlugin implements IPlugin {      [".jpg", "jpegoptim"],import { parseFigmaURL, formatFigmaURL } from "./utils";
+
+  public readonly name = "figma";
+
+  public readonly description = "Download assets from Figma";    ]);import {
+
+
+
+  configParser(parser: ArgumentParser): void {    const binaryName = binaryForExtensions.get(extension);  loadConfig,
+
+    parser.add_argument("--token", {
+
+      help: "Figma API token (can also use FIGMA_TOKEN env var)",  mergeConfigWithArgs,
+
+    });
+
+    parser.add_argument("--config", {    if (!binaryName) {  validateRequiredConfig,
+
+      help: "Path to TypeScript config file (default: looks for ixt.config.ts in current directory)",
+
+    });      // console.log(`;
+    No;
+    optimizer;
+    found;
+    for ($; { extension }, skipping; optimization `);  type FigmaConfig,
+
+    const commands = parser.add_subparsers({
+
+      title: "commands",      return;} from "../../config";
+
+      dest: "command",
+
+    });    }import { IPlugin } from "../types";
+
+    const downloadParser = commands.add_parser("download", {
+
+      help: "Download assets from Figma",
+
+    });
+
+    downloadParser.add_argument("name", {    const binaryPath = execSync(`)
+        which;
+    $;
+    {
+        binaryName;
+    }
+    `).toString().trim();const optimizeImage = async (filepath: string): Promise<void> => {
+
+      help: "Pass this to only download assets for a specific name defined in the config",
+
+    });  try {
+
+    const getParser = commands.add_parser("get", {
+
+      help: "Get the Figma node for a given URL",    if (!binaryPath) {    const extension = path.extname(filepath).toLowerCase();
+
+    });
+
+    getParser.add_argument("url", {      throw new Error(`;
+    Cannot;
+    find;
+    $;
+    {
+        binaryName;
+    }
+     in PATH.Please;
+    install;
+    it. `);    const binaryForExtensions = new Map<string, string>([
+
+      help: "The Figma URL to fetch the node from",
+
+    });    }      [".png", "optipng"],
+
+  }
+
+      [".jpg", "jpegoptim"],
+
+  async run(parser: ArgumentParser): Promise<void> {
+
+    const args = parser.parse_args() as    console.log(`;
+    Optimizing;
+    with ($) {
+        filepath;
+    }
+    with ($) {
+        binaryName;
+    }
+    `);    ]);
+
+      | {
+
+          config?: string;    await execSync(`;
+    $;
+    {
+        binaryPath;
+    }
+    "${filepath}" `);    const binaryName = binaryForExtensions.get(extension);
+
+          token?: string;
+
+          name?: string;    console.log(`;
+    Image;
+    optimized;
+    successfully: $;
+    {
+        filepath;
+    }
+    `);
+
+          command: "download";
+
+        }  } catch (error) {    if (!binaryName) {
+
+      | {
+
+          config?: string;    console.error(      // console.log(`;
+    No;
+    optimizer;
+    found;
+    for ($; { extension }, skipping; optimization `);
+
+          token?: string;
+
+          command: "get";      `)
+        Error;
+    optimizing;
+    image;
+    $;
+    {
+        filepath;
+    }
+    $;
+    {
+        return;
+        url: string;
+    }
+    ;
+    error instanceof Error ? error.message : error;
+}
+// Load configuration      }`
+const config = await (0, module_1.loadConfig)(args.config);
+;
+const binaryPath = (0, child_process_1.execSync)(`which ${binaryName}`).toString().trim();
+// Merge CLI args with config, giving precedence to CLI args
+const mergedConfig = mergeConfigWithArgs();
+config,
+    {};
+if (!binaryPath) {
+    token: args.token || process.env.FIGMA_TOKEN,
+    ;
+}
+throw new Error(`Cannot find ${binaryName} in PATH. Please install it.`);
+"figma";
+as;
+FigmaConfig & { token: string };
+class FigmaPlugin {
+}
+exports.FigmaPlugin = FigmaPlugin;
+// Validate required configuration  public readonly name = "figma";
+validateRequiredConfig(mergedConfig, ["token"]);
+description = "Download assets from Figma";
+console.log(`Optimizing with ${filepath} with ${binaryName}`);
+const api = (0, api_1.createAPI)(mergedConfig.token);
+const assets = mergedConfig.assets || [];
+await (0, child_process_1.execSync)(`${binaryPath} "${filepath}"`);
+if (args.command === "download") {
+    configParser(parser, argparse_1.ArgumentParser);
+    void { console, : .log(`Image optimized successfully: ${filepath}`),
+        if(assets) { }, : .length === 0 };
+    {
+        throw new Error(parser.add_argument("--token", {}));
+        try { }
+        catch (error) {
+            "No figma assets configured. Please add assets to your config file.";
+            ;
+            help: "Figma API token (can also use FIGMA_TOKEN env var)", console.error();
+        }
+    }
+    ;
+    `Error optimizing image ${filepath}: ${;
+    for (const { url, output, name } of assets) {
+        if (args.name && name !== args.name) {
+            parser.add_argument("--config", { error, instanceof: Error ? error.message : error,
+                continue: 
+            }, help, "Path to TypeScript config file (default: looks for ixt.config.ts in current directory)");
+        }
+        `
+
+        const { figmaFileId, figmaPageId } = parseFigmaURL(url);
+
+        console.log({ figmaFileId, figmaPageId });    });    );
+
+        console.log(
+
+          `;
+        Reading;
+        assets;
+        for ("${name}"; at; $) {
+            (0, utils_1.formatFigmaURL)();
+            const commands = parser.add_subparsers({}, figmaFileId, figmaPageId, title, "commands");
+        }
+        ;
+    }
+    `
+
+        );      dest: "command",
+
+        const spinner = ora("Fetching images").start();
+
+        let total = -1;    });export class FigmaPlugin implements IPlugin {
+
+        let fetched = 0;
+
+        const images = await api.images.fetch(figmaFileId, [figmaPageId], {    const downloadParser = commands.add_parser("download", {  public readonly name = "figma";
+
+          onFetchSources: (sources) => {
+
+            total = sources.length;      help: "Download assets from Figma",  public readonly description = "Download assets from Figma";
+
+            spinner.text = `;
+    Fetching;
+    $;
+    {
+        total;
+    }
+    image(s) `;
+
+            spinner.render();    });
+
+          },
+
+          onFetchImage: (_url) => {    downloadParser.add_argument("name", {  configParser(parser: ArgumentParser): void {
+
+            fetched += 1;
+
+            spinner.text = `;
+    Fetched;
+    $;
+    {
+        fetched;
+    }
+    /${total} image(s)`;      help: "Pass this to only download assets for a specific name defined in the config",    parser.add_argument("--token", {;
+    spinner.render();
+}
+;
+help: "Figma API token (can also use FIGMA_TOKEN env var)",
+;
+;
+spinner.stop();
+const getParser = commands.add_parser("get", {});
+console.log(`${images.length} asset(s) downloaded`);
+for (const im of images) {
+    help: "Get the Figma node for a given URL", parser.add_argument("--config", {
+        const: filename = `${im.name}.${im.format}`,
+        console, : .log(`Downloaded ${filename}`)
+    });
+    help: "Path to TypeScript config file (default: looks for ixt.config.ts in current directory)",
+    ;
+    const outputFile = path.join(output, filename);
+    const outputDir = path.dirname(outputFile);
+    getParser.add_argument("url", {});
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.writeFile(path.join(output, filename), im.data);
+    help: "The Figma URL to fetch the node from", ;
+    const commands = parser.add_subparsers({
+        await
+    });
+}
+;
+title: "commands",
+;
+if (args.command === "get") { }
+dest: "command",
+;
+const { figmaFileId, figmaPageId } = (0, utils_1.parseFigmaURL)(args.url);
+const node = await api.nodes.fetch(figmaFileId, [figmaPageId]);
+;
+console.log(JSON.stringify(node, null, 2));
+async;
+(0, exports.run)(parser, argparse_1.ArgumentParser);
+Promise < void  > { const: downloadParser = commands.add_parser("download", {})
+};
+const args = parser.parse_args();
+"Download assets from Figma",
+        | {};
+;
+config ?  : string;
+downloadParser.add_argument("name", {
+    token: string, help: "Pass this to only download assets for a specific name defined in the config",
+    name: string
+});
+command: "download";
+const getParser = commands.add_parser("get", {}, help, "Get the Figma node for a given URL", 
+    | {});
+config ?  : string;
+getParser.add_argument("url", {
+    token: string, help: "The Figma URL to fetch the node from",
+    command: "get"
+});
+url: string;
+;
+const run = async (parser) => {
+    // Load configuration  const args = parser.parse_args() as
+    const config = await (0, module_1.loadConfig)(args.config);
+     | {
+        config: string,
+        // Merge CLI args with config, giving precedence to CLI args        token?: string;
+        const: mergedConfig = mergeConfigWithArgs(name ?  : string),
+        config, command: "download"
+    };
+    { }
+    token: args.token || process.env.FIGMA_TOKEN,  | {}, config ?  : string;
+    "figma";
+    token ?  : string;
+};
+exports.run = run;
+as;
+FigmaConfig & { token: string };
+command: "get";
+url: string;
+// Validate required configuration      };
+validateRequiredConfig(mergedConfig, ["token"]);
+// Load configuration
+const api = (0, api_1.createAPI)(mergedConfig.token);
+const config = await (0, module_1.loadConfig)(args.config);
+const assets = mergedConfig.assets || [];
+// Merge CLI args with config, giving precedence to CLI args
+if (args.command === "download") {
+    const mergedConfig = mergeConfigWithArgs();
+    if (assets.length === 0) {
+        config,
+        ;
+        throw new Error({
+            "No figma assets configured. Please add assets to your config file.": token, args, : .token || process.env.FIGMA_TOKEN,
+        });
+    }
+}
+"figma";
+as;
+FigmaConfig & { token: string };
+for (const { url, output, name } of assets) {
+    if (args.name && name !== args.name) { // Validate required configuration
+        continue;
+        validateRequiredConfig(mergedConfig, ["token"]);
+    }
+    const { figmaFileId, figmaPageId } = (0, utils_1.parseFigmaURL)(url);
+    const api = (0, api_1.createAPI)(mergedConfig.token);
+    console.log({ figmaFileId, figmaPageId });
+    const assets = mergedConfig.assets || [];
+    console.log(`Reading assets for "${name}" at ${(0, utils_1.formatFigmaURL)());
+    if (args.command === "download") {
+        figmaFileId, ;
+        if (assets.length === 0) {
+            figmaPageId;
+            throw new Error();
+        }
+        `        "No figma assets configured. Please add assets to your config file."
+
+        );      );
+
+        const spinner = ora("Fetching images").start();    }
+
+        let total = -1;
+
+        let fetched = 0;    for (const { url, output, name } of assets) {
+
+        const images = await api.images.fetch(figmaFileId, [figmaPageId], {      if (args.name && name !== args.name) {
+
+          onFetchSources: (sources) => {        continue;
+
+            total = sources.length;      }
+
+            spinner.text = `;
+        Fetching;
+        $;
+        {
+            total;
+        }
+        image(s) `;      const { figmaFileId, figmaPageId } = parseFigmaURL(url);
+
+            spinner.render();      console.log({ figmaFileId, figmaPageId });
+
+          },      console.log(
+
+          onFetchImage: (_url) => {        `;
+        Reading;
+        assets;
+        for ("${name}"; at; $) {
+            (0, utils_1.formatFigmaURL)(fetched += 1);
+            figmaFileId,
+                spinner.text = `Fetched ${fetched}/${total} image(s)`;
+            figmaPageId;
+            spinner.render();
+        }
+        `
+
+          },      );
+
+        });      const spinner = ora("Fetching images").start();
+
+        spinner.stop();      let total = -1;
+
+        console.log(`;
+        $;
+        {
+            images.length;
+        }
+        asset(s);
+        downloaded `);      let fetched = 0;
+
+        for (const im of images) {      const images = await api.images.fetch(figmaFileId, [figmaPageId], {
+
+          const filename = `;
+        $;
+        {
+            im.name;
+        }
+        $;
+        {
+            im.format;
+        }
+        `;        onFetchSources: (sources) => {
+
+          console.log(`;
+        Downloaded;
+        $;
+        {
+            filename;
+        }
+        `);          total = sources.length;
+
+          const outputFile = path.join(output, filename);          spinner.text = `;
+        Fetching;
+        $;
+        {
+            total;
+        }
+        image(s) `;
+
+          const outputDir = path.dirname(outputFile);          spinner.render();
+
+          await fs.mkdir(outputDir, { recursive: true });        },
+
+          await fs.writeFile(path.join(output, filename), im.data);        onFetchImage: (_url) => {
+
+          await optimizeImage(outputFile);          fetched += 1;
+
+        }          spinner.text = `;
+        Fetched;
+        $;
+        {
+            fetched;
+        }
+        /${total} image(s)`;;
+    }
+    spinner.render();
+}
+if (args.command === "get") { }
+const { figmaFileId, figmaPageId } = (0, utils_1.parseFigmaURL)(args.url);
+;
+const node = await api.nodes.fetch(figmaFileId, [figmaPageId]);
+spinner.stop();
+console.log(JSON.stringify(node, null, 2));
+console.log(`${images.length} asset(s) downloaded`);
+for (const im of images) {
+}
+const filename = `${im.name}.${im.format}`;
+console.log(`Downloaded ${filename}`);
+const outputFile = path.join(output, filename);
+const outputDir = path.dirname(outputFile);
+await fs.mkdir(outputDir, { recursive: true });
+await fs.writeFile(path.join(output, filename), im.data);
+await optimizeImage(outputFile);
+if (args.command === "get") {
+    const { figmaFileId, figmaPageId } = (0, utils_1.parseFigmaURL)(args.url);
+    const node = await api.nodes.fetch(figmaFileId, [figmaPageId]);
+    console.log(JSON.stringify(node, null, 2));
+}
+;
+const optimizeImage = async (filepath) => {
+    try {
+        const extension = path.extname(filepath).toLowerCase();
+        const binaryForExtensions = new Map([
+            [".png", "optipng"],
+            [".jpg", "jpegoptim"],
+        ]);
+        const binaryName = binaryForExtensions.get(extension);
+        if (!binaryName) {
+            // console.log(`No optimizer found for ${extension}, skipping optimization`);
+            return;
+        }
+        const binaryPath = (0, child_process_1.execSync)(`which ${binaryName}`).toString().trim();
+        if (!binaryPath) {
+            throw new Error(`Cannot find ${binaryName} in PATH. Please install it.`);
+        }
+        console.log(`Optimizing with ${filepath} with ${binaryName}`);
+        await (0, child_process_1.execSync)(`${binaryPath} "${filepath}"`);
+        console.log(`Image optimized successfully: ${filepath}`);
+    }
+    catch (error) {
+        console.error(`Error optimizing image ${filepath}: ${error instanceof Error ? error.message : error}`);
+    }
+};
+const main = async () => {
+    const parser = new argparse_1.ArgumentParser({
+        description: "Download assets from Figma",
+    });
+    configParser(parser);
+    await (0, exports.run)(parser);
+};
+// Only run main if this file is being executed directly
+if (require.main === module) {
+    main().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}