nautobot 2.1.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

nautobot/core/management/commands/build_ui.py

@@ -1,281 +0,0 @@
-import copy
-from importlib import import_module
-import json
-import os
-from pathlib import Path
-import re
-import shlex
-import subprocess
-
-from django.apps import apps
-from django.conf import settings
-from django.contrib.admindocs.views import simplify_regex
-from django.core.management.base import BaseCommand, CommandError
-import jinja2
-
-
-class Command(BaseCommand):
-    help = "Build the user interface for the Nautobot server environment and installed Nautobot Apps."
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--npm-install",
-            action="store_true",
-            dest="npm_install",
-            default=False,
-            help="Install UI packages.",
-        )
-        parser.add_argument(
-            "--no-render-apps",
-            action="store_false",
-            dest="render_apps",
-            default=True,
-            help="Do not (re)render Nautobot App imports.",
-        )
-        parser.add_argument(
-            "--no-npm-build",
-            action="store_false",
-            dest="npm_build",
-            default=True,
-            help="Do not compile UI.",
-        )
-
-    def convert_django_url_regex_to_react_route_path(self, regex):
-        """
-        Converts a regular expression object to its equivalent react router path representation.
-
-        Args:
-            regex (re.Pattern): A regular expression object.
-
-        Example:
-            >>> pattern = re.compile('^other-models/(?P<pk>[^/.]+)/notes/$')
-            >>> convert_django_url_regex_to_react_route_path(pattern)
-            '/other-models/:pk/notes/'
-        """
-        pattern = str(regex.pattern)
-        path = simplify_regex(pattern).replace("<", ":").replace(">", "").replace("\\Z", "").replace("\\", "")
-        return path if path.endswith("/") else f"{path}/"
-
-    def get_app_component(self, file_path, route_name):
-        """
-        Obtains the view component for the given route name from the index.js file of the App.
-        This locates the `route_name` in the app configuration `routes_view_components` dict and
-        returns the View Component registered for the `route_name`.
-
-        Parameters:
-            file_path (str): The path to the JavaScript file to read from.
-            route_name (str): The name of the route to extract the view component for.
-
-        Returns:
-            str: The view component associated with the specified route name, or None if not found.
-
-        Example:
-            >>> get_app_component(file_path="/src/example_plugin/example_plugin/ui/index.js", route_name="example-plugin:examplemodel_list")
-            "ExampleModelListView"
-        """
-        try:
-            with open(file_path, "r") as f:
-                js_content = f.read()
-        except FileNotFoundError:
-            return None
-
-        # Construct a regular expression that matches the specified key and extracts the associated view component
-        pattern = rf'routes_view_components:\s*{{[^}}]*"{re.escape(route_name)}"\s*:\s*"([^"]+)"'
-        view_component_match = re.search(pattern, js_content)
-        return view_component_match[1] if view_component_match else None
-
-    def render_routes_imports(self, app_base_path, app_name, app_config):
-        """
-        Renders the imports for the React Router components of the App's URLs.
-
-        This method inspects the `urlpatterns` list of the `urls.py` module of the App and generates
-        a list of dictionaries representing the React Router components and their corresponding URL paths.
-
-        Args:
-            app_base_path (Path): The base path of the Django app.
-            app_name (str): The name of the Django app.
-            app_config (AppConfig): The configuration object of the Django app.
-
-        Returns:
-            List[Dict[str, str]]: A list of dictionaries representing the React Router components and their
-            corresponding URL paths.
-            Each dictionary has the following keys:
-            - "path": The URL path pattern.
-            - "component": The React component associated with the URL path.
-
-        Example:
-            >>> render_routes_imports("/src/example_plugin/", "example_plugin", <AppConfig instance>)
-            [
-                { "path": "example-plugin/", "component": "HomeView"},
-                { "path": "example-plugin/config/", "component": "ConfigView"},
-            ]
-        """
-        data = []
-        try:
-            module = import_module(f"{app_name}.urls")
-            base_url = app_config.base_url or app_config.label
-            for urlpattern in module.urlpatterns:
-                if component := self.get_app_component(
-                    app_base_path / "ui/index.js",
-                    f"{base_url}:{urlpattern.name}",
-                ):
-                    path_regex = urlpattern.pattern.regex
-                    url_path = self.convert_django_url_regex_to_react_route_path(path_regex)
-                    data.append({"path": base_url + url_path, "component": component})
-            return data
-        except (AttributeError, ModuleNotFoundError):
-            # If an app does not include its url.py file or urls.py does not include a urlpatterns, skip.
-            return data
-
-    def render_app_imports(self, render_apps=False):
-        """
-        Render dynamically constructed app-related files - `app_imports.js`, `app_routes.json`, `jsconfig.paths.json`.
-
-        - If `render_apps` is True, these files will be regenerated according to the apps included in settings.PLUGINS.
-        - If `render_apps` is False but the files do not yet exist, they will be created but will not include any apps.
-        - If `render_apps` is False and the files already exist, they will be left untouched.
-        """
-
-        ui_dir = settings.NAUTOBOT_UI_DIR
-
-        # Input files
-        router_file_path = Path(ui_dir, "src", "router.js")
-        jsconfig_base_file_path = Path(ui_dir, "src", "file_templates", "jsconfig-base.json")
-        environment = jinja2.sandbox.SandboxedEnvironment(
-            loader=jinja2.FileSystemLoader(Path(ui_dir, "src", "file_templates"))
-        )
-        template = environment.get_template("app_imports.js.j2")
-
-        # Output files
-        output_dir = Path(ui_dir, "generated")
-        os.makedirs(output_dir, exist_ok=True)
-        jsconfig_file_path = Path(output_dir, "jsconfig.paths.json")
-        app_routes_file_path = Path(output_dir, "app_routes.json")
-        app_imports_final_file_path = Path(output_dir, "app_imports.js")
-
-        app_routes = {}
-        with open(jsconfig_base_file_path, "r", encoding="utf-8") as base_config_file:
-            jsconfig = json.load(base_config_file)
-
-        if render_apps:
-            self.stdout.write(self.style.WARNING(">>> Rendering Nautobot App imports..."))
-            # We're going to modify this list if apps don't have a `ui` directory.
-            enabled_apps = copy.copy(settings.PLUGINS)
-
-            for app_class_path in settings.PLUGINS:
-                app_name = app_class_path.split(".")[-1]
-                app_config = apps.get_app_config(app_name)
-                abs_app_path = Path(app_config.path).resolve()
-                abs_app_ui_path = abs_app_path / "ui"
-                app_path = Path(os.path.relpath(abs_app_path, ui_dir))
-                app_ui_path = app_path / "ui"
-                if app_routes_imports := self.render_routes_imports(abs_app_path, app_name, app_config):
-                    app_routes[app_name] = app_routes_imports
-
-                # Assert that an App has a UI folder.
-                if not abs_app_ui_path.exists():
-                    self.stdout.write(self.style.ERROR(f"    - App {app_name!r} does not publish a UI; Skipping..."))
-                    enabled_apps.remove(app_class_path)
-                    continue
-                self.stdout.write(self.style.SUCCESS(f"    - App {app_name!r} imported"))
-
-                jsconfig["compilerOptions"]["paths"][f"@{app_name}/*"] = [f"{app_ui_path}/*"]
-        else:
-            enabled_apps = []
-
-        files_generated = False
-
-        if render_apps or not os.path.exists(jsconfig_file_path):
-            with open(jsconfig_file_path, "w", encoding="utf-8") as generated_config_file:
-                json.dump(jsconfig, generated_config_file, indent=4)
-            self.stdout.write(self.style.SUCCESS(f"    - Rendered {jsconfig_file_path}"))
-            files_generated = True
-
-        if render_apps or not os.path.exists(app_routes_file_path):
-            with open(app_routes_file_path, "w", encoding="utf-8") as app_routes_file:
-                json.dump(app_routes, app_routes_file, indent=4)
-            self.stdout.write(self.style.SUCCESS(f"    - Rendered {app_routes_file_path}"))
-            files_generated = True
-
-        if render_apps or not os.path.exists(app_imports_final_file_path):
-            content = template.render(apps=enabled_apps)
-            with open(app_imports_final_file_path, "w", encoding="utf-8") as generated_import_file:
-                generated_import_file.write(content)
-            self.stdout.write(self.style.SUCCESS(f"    - Rendered {app_imports_final_file_path}"))
-            files_generated = True
-
-        if files_generated:
-            # Touch the router to attempt to trigger a server reload.
-            Path(router_file_path).touch()
-
-    def run_command(self, command, message, cwd=settings.NAUTOBOT_UI_DIR):
-        """
-        Run a `command`, displaying `message` and exit. This splits it for you and runs it.
-
-        Args:
-            command (str): The command to execute
-            message (str): Message to display when command is executed
-        """
-        self.stdout.write(self.style.WARNING(message))
-        self.stdout.write(f"Running '{command}' in '{cwd}'...")
-
-        try:
-            result = subprocess.run(
-                shlex.split(command),
-                check=False,
-                cwd=cwd,
-                env={**os.environ.copy()},
-                encoding="utf-8",
-                capture_output=True,
-            )
-        except FileNotFoundError as err:
-            raise CommandError(f"'{command}' failed with error: {err}")
-
-        if result.returncode:
-            self.stdout.write(self.style.NOTICE(result.stdout))
-            self.stderr.write(self.style.ERROR(result.stderr))
-            raise CommandError(f"'{command}' failed with exit code {result.returncode}")
-
-    def handle(self, *args, **options):
-        verbosity = options["verbosity"]
-
-        # NAUTOBOT_DEBUG is also set here so that `console.log` isn't suppressed when we want
-        # verbosity.
-        if verbosity > 1:
-            os.environ["NAUTOBOT_DEBUG"] = "1"
-
-        verbosity_map = {
-            0: "silent",
-            1: "notice",
-            2: "info",
-            3: "silly",  # MAXIMUM OVERDEBUG
-        }
-        loglevel = f"--loglevel {verbosity_map[verbosity]}"
-
-        if not os.path.exists(Path(settings.NAUTOBOT_UI_DIR)):
-            os.makedirs(Path(settings.NAUTOBOT_UI_DIR))
-
-        self.run_command(
-            f"cp -r {Path(settings.BASE_DIR, 'ui')}/. {Path(settings.NAUTOBOT_UI_DIR)}",
-            ">>> Copying UI source files...",
-        )
-
-        # Generate `app_imports.js`, `app_routes.json`, and `jsconfig.paths.json` if necessary or if requested.
-        self.render_app_imports(options["render_apps"])
-
-        # Run `npm install` and keep it silent by default.
-        if options["npm_install"]:
-            args = f"install {loglevel} --no-progress"
-            self.run_command(f"npm {args}", ">>> Installing Nautobot UI dependencies...")
-
-        # Run `npm build` and keep it silent by default.
-        if options["npm_build"]:
-            args = f"run build {loglevel}"
-            self.run_command(f"npm {args}", ">>> Compiling Nautobot UI packages...")
-            self.run_command(
-                f"cp {Path(settings.NAUTOBOT_UI_DIR, 'build' ,'asset-manifest.json')} "
-                f"{Path(settings.NAUTOBOT_UI_DIR, 'build' , 'static', 'asset-manifest.json')}",
-                ">>> Copying built manifest...",
-            )
-
-        self.stdout.write(self.style.SUCCESS(">>> Nautobot UI build complete! 🎉"))

nautobot/core/templates/base_react.html

@@ -1,55 +0,0 @@
-{% load static %}
-{% load helpers %}
-{% load plugins %}
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" href="/static/img/favicon.ico" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="theme-color" content="#000000" />
-    <meta
-      name="description"
-      content="Web site created using create-react-app"
-    />
-    <link rel="apple-touch-icon" href="/logo192.png" />
-    <!--
-      manifest.json provides metadata used when your web app is installed on a
-      user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
-    -->
-    <link rel="manifest" href="{% static 'asset-manifest.json' %}" />
-    <link
-      href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&amp;display=swap"
-      rel="stylesheet"
-    />
-    <!--
-      Notice the use of %PUBLIC_URL% in the tags above.
-      It will be replaced with the URL of the `public` folder during the build.
-      Only files inside the `public` folder can be referenced from the HTML.
-
-      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
-      work correctly both with client-side routing and a non-root public URL.
-      Learn how to configure a non-root public URL by running `npm run build`.
-    -->
-    <title>{{ settings.BRANDING_TITLE }}</title>
-    <script defer src="{% static 'js/main.js' %}"></script>
-    <link href="{% static 'css/main.css' %}" rel="stylesheet">
-  </head>
-  <body>
-    <noscript>You need to enable JavaScript to run this app.</noscript>
-    <div id="root"></div>
-    <div id="legacy-content" style="display:none">
-      {% block content %}{% endblock content %}
-    </div>
-    <!--
-      This HTML file is a template.
-      If you open it directly in the browser, you will see an empty page.
-
-      You can add webfonts, meta tags, or analytics to this file.
-      The build step will place the bundled scripts into the <body> tag.
-
-      To begin the development, run `npm start` or `yarn start`.
-      To create a production bundle, use `npm run build` or `yarn build`.
-    -->
-  </body>
-</html>

nautobot/core/tests/test_cli.py

@@ -1,25 +0,0 @@
-"""Initial testing of cli.py"""
-
-from nautobot.core import cli
-
-
-class TestCli:
-    def test_cli_setting_monkey_patch_return_value(self):
-        """Validate _setting works provides the expected return value."""
-        storages_config = {
-            "AWS_ACCESS_KEY_ID": "ASFWDAMWWOQMEOQMWPMDA<WPDA",
-            "AWS_SECRET_ACCESS_KEY": "ASFKMWADMsacasdaw/dawrt1231541231231",
-            "AWS_STORAGE_BUCKET_NAME": "nautobot",
-            "AWS_S3_REGION_NAME": "us-west-1",
-        }
-        global_config = {"USE_TZ": True}
-        configs = storages_config.update(global_config)
-        for setting, value in configs.items():
-            result = cli._configure_settings._setting(setting)
-            assert result == value
-
-    def test_cli_setting_monkey_patch_return_none(self):
-        """Validate _setting returns none for non-existent setting."""
-        configs = ("AWS_NON_EXISTENT_KEY", "STORAGE_NON_EXISTENT_KEY")
-        for setting in configs:
-            assert not cli._configure_settings._setting(setting)

nautobot/ui/.eslintignore

@@ -1,3 +0,0 @@
-build
-# These files get rendered by `nautobot-server build_ui`
-generated

nautobot/ui/.gitignore

@@ -1,7 +0,0 @@
-build
-# These files get rendered by `nautobot-server build_ui`
-generated
-node_modules
-
-# The output of `npm run analyze`
-analyze_report.html

nautobot/ui/.prettierignore

@@ -1,6 +0,0 @@
-build
-# These files get rendered by `nautobot-server build_ui`
-generated
-
-# This is generated when running `npm run analyze`
-analyze_report.html

nautobot/ui/.prettierrc

@@ -1,4 +0,0 @@
-{
-    "tabWidth": 4,
-    "useTabs": false
-}

nautobot/ui/README.md

@@ -1,27 +0,0 @@
-# Nautobot v2 UI Prototype
-
-## Running it
-
-Install and compile dependencies (note that you'll only use `--npm-install` on initial setup):
-
-```no-highlight
-nautobot-server build_ui --npm-install
-```
-
-Start Nautobot on port `8080/tcp`:
-
-```no-highlight
-nautobot-server runserver 0.0.0.0:8080 --insecure
-```
-
-## Running test
-
-To run all UI test suites, run:
-
-```no-highlight
-invoke unittest-ui
-```
-
-## Debugging Startup/Build Failures
-
-Nautobot will attempt to build the UI on startup when running `post_upgrade` but during development the React project may fail to build, never allowing the Node.JS container from starting. In that situation, skip running the `post_upgrade` until the React app can start. In container workflows that will mean setting the `NAUTOBOT_DOCKER_SKIP_INIT` environment variable to `True`.

nautobot/ui/config/env.js

@@ -1,102 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const paths = require("./paths");
-
-// Make sure that including paths.js after env.js will read .env variables.
-delete require.cache[require.resolve("./paths")];
-
-const NODE_ENV = process.env.NODE_ENV;
-if (!NODE_ENV) {
-    throw new Error(
-        "The NODE_ENV environment variable is required but was not specified."
-    );
-}
-
-// https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use
-const dotenvFiles = [
-    `${paths.dotenv}.${NODE_ENV}.local`,
-    // Don't include `.env.local` for `test` environment
-    // since normally you expect tests to produce the same
-    // results for everyone
-    NODE_ENV !== "test" && `${paths.dotenv}.local`,
-    `${paths.dotenv}.${NODE_ENV}`,
-    paths.dotenv,
-].filter(Boolean);
-
-// Load environment variables from .env* files. Suppress warnings using silent
-// if this file is missing. dotenv will never modify any environment variables
-// that have already been set.  Variable expansion is supported in .env files.
-// https://github.com/motdotla/dotenv
-// https://github.com/motdotla/dotenv-expand
-dotenvFiles.forEach((dotenvFile) => {
-    if (fs.existsSync(dotenvFile)) {
-        require("dotenv-expand")(
-            require("dotenv").config({
-                path: dotenvFile,
-            })
-        );
-    }
-});
-
-// We support resolving modules according to `NODE_PATH`.
-// This lets you use absolute paths in imports inside large monorepos:
-// https://github.com/facebook/create-react-app/issues/253.
-// It works similar to `NODE_PATH` in Node itself:
-// https://nodejs.org/api/modules.html#modules_loading_from_the_global_folders
-// Note that unlike in Node, only *relative* paths from `NODE_PATH` are honored.
-// Otherwise, we risk importing Node.js core modules into an app instead of webpack shims.
-// https://github.com/facebook/create-react-app/issues/1023#issuecomment-265344421
-// We also resolve them to make sure all tools using them work consistently.
-const appDirectory = fs.realpathSync(process.cwd());
-process.env.NODE_PATH = (process.env.NODE_PATH || "")
-    .split(path.delimiter)
-    .filter((folder) => folder && !path.isAbsolute(folder))
-    .map((folder) => path.resolve(appDirectory, folder))
-    .join(path.delimiter);
-
-// Grab NODE_ENV and REACT_APP_* environment variables and prepare them to be
-// injected into the application via DefinePlugin in webpack configuration.
-const REACT_APP = /^REACT_APP_/i;
-
-function getClientEnvironment(publicUrl) {
-    const raw = Object.keys(process.env)
-        .filter((key) => REACT_APP.test(key))
-        .reduce(
-            (env, key) => {
-                env[key] = process.env[key];
-                return env;
-            },
-            {
-                // Useful for determining whether we’re running in production mode.
-                // Most importantly, it switches React into the correct mode.
-                NODE_ENV: process.env.NODE_ENV || "development",
-                // Useful for resolving the correct path to static assets in `public`.
-                // For example, <img src={process.env.PUBLIC_URL + '/img/logo.png'} />.
-                // This should only be used as an escape hatch. Normally you would put
-                // images into the `src` and `import` them in code to get their paths.
-                PUBLIC_URL: publicUrl,
-                // We support configuring the sockjs pathname during development.
-                // These settings let a developer run multiple simultaneous projects.
-                // They are used as the connection `hostname`, `pathname` and `port`
-                // in webpackHotDevClient. They are used as the `sockHost`, `sockPath`
-                // and `sockPort` options in webpack-dev-server.
-                WDS_SOCKET_HOST: process.env.WDS_SOCKET_HOST,
-                WDS_SOCKET_PATH: process.env.WDS_SOCKET_PATH,
-                WDS_SOCKET_PORT: process.env.WDS_SOCKET_PORT,
-                // Whether or not react-refresh is enabled.
-                // It is defined here so it is available in the webpackHotDevClient.
-                FAST_REFRESH: process.env.FAST_REFRESH !== "false",
-            }
-        );
-    // Stringify all values so we can feed into webpack DefinePlugin
-    const stringified = {
-        "process.env": Object.keys(raw).reduce((env, key) => {
-            env[key] = JSON.stringify(raw[key]);
-            return env;
-        }, {}),
-    };
-
-    return { raw, stringified };
-}
-
-module.exports = getClientEnvironment;

nautobot/ui/config/getHttpsConfig.js

@@ -1,68 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-const chalk = require("react-dev-utils/chalk");
-const paths = require("./paths");
-
-// Ensure the certificate and key provided are valid and if not
-// throw an easy to debug error
-function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
-    let encrypted;
-    try {
-        // publicEncrypt will throw an error with an invalid cert
-        encrypted = crypto.publicEncrypt(cert, Buffer.from("test"));
-    } catch (err) {
-        throw new Error(
-            `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${
-                err.message
-            }`
-        );
-    }
-
-    try {
-        // privateDecrypt will throw an error with an invalid key
-        crypto.privateDecrypt(key, encrypted);
-    } catch (err) {
-        throw new Error(
-            `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
-                err.message
-            }`
-        );
-    }
-}
-
-// Read file and throw an error if it doesn't exist
-function readEnvFile(file, type) {
-    if (!fs.existsSync(file)) {
-        throw new Error(
-            `You specified ${chalk.cyan(
-                type
-            )} in your env, but the file "${chalk.yellow(
-                file
-            )}" can't be found.`
-        );
-    }
-    return fs.readFileSync(file);
-}
-
-// Get the https config
-// Return cert files if provided in env, otherwise just true or false
-function getHttpsConfig() {
-    const { SSL_CRT_FILE, SSL_KEY_FILE, HTTPS } = process.env;
-    const isHttps = HTTPS === "true";
-
-    if (isHttps && SSL_CRT_FILE && SSL_KEY_FILE) {
-        const crtFile = path.resolve(paths.appPath, SSL_CRT_FILE);
-        const keyFile = path.resolve(paths.appPath, SSL_KEY_FILE);
-        const config = {
-            cert: readEnvFile(crtFile, "SSL_CRT_FILE"),
-            key: readEnvFile(keyFile, "SSL_KEY_FILE"),
-        };
-
-        validateKeyAndCerts({ ...config, keyFile, crtFile });
-        return config;
-    }
-    return isHttps;
-}
-
-module.exports = getHttpsConfig;

nautobot/ui/config/jest/babelTransform.js

@@ -1,14 +0,0 @@
-const babelJest = require("babel-jest").default;
-
-module.exports = babelJest.createTransformer({
-    presets: [
-        [
-            require.resolve("babel-preset-react-app"),
-            {
-                runtime: "automatic",
-            },
-        ],
-    ],
-    babelrc: false,
-    configFile: false,
-});

nautobot/ui/config/jest/cssTransform.js

@@ -1,12 +0,0 @@
-// This is a custom Jest transformer turning style imports into empty objects.
-// http://facebook.github.io/jest/docs/en/webpack.html
-
-module.exports = {
-    process() {
-        return "module.exports = {};";
-    },
-    getCacheKey() {
-        // The output is always the same.
-        return "cssTransform";
-    },
-};

nautobot/ui/config/jest/fileTransform.js

@@ -1,38 +0,0 @@
-const path = require("path");
-const camelcase = require("camelcase");
-
-// This is a custom Jest transformer turning file imports into filenames.
-// http://facebook.github.io/jest/docs/en/webpack.html
-
-module.exports = {
-    process(src, filename) {
-        const assetFilename = JSON.stringify(path.basename(filename));
-
-        if (filename.match(/\.svg$/)) {
-            // Based on how SVGR generates a component name:
-            // https://github.com/smooth-code/svgr/blob/01b194cf967347d43d4cbe6b434404731b87cf27/packages/core/src/state.js#L6
-            const pascalCaseFilename = camelcase(path.parse(filename).name, {
-                pascalCase: true,
-            });
-            const componentName = `Svg${pascalCaseFilename}`;
-            return `const React = require('react');
-      module.exports = {
-        __esModule: true,
-        default: ${assetFilename},
-        ReactComponent: React.forwardRef(function ${componentName}(props, ref) {
-          return {
-            $$typeof: Symbol.for('react.element'),
-            type: 'svg',
-            ref: ref,
-            key: null,
-            props: Object.assign({}, props, {
-              children: ${assetFilename}
-            })
-          };
-        }),
-      };`;
-        }
-
-        return `module.exports = ${assetFilename};`;
-    },
-};