@storm-stack/core/dist/lib/chunk-INCUEWRR.cjs

A build toolkit and runtime used by Storm Software in TypeScript applications

'use strict';

var helperPluginUtils = require('@babel/helper-plugin-utils');
var template = require('@babel/template');
var t = require('@babel/types');
var toArray = require('@stryke/convert/to-array');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var template__default = /*#__PURE__*/_interopDefault(template);
var t__namespace = /*#__PURE__*/_interopNamespace(t);

// src/lib/babel/plugins/builtin-extend.ts
var buildHelper = template__default.default(`
    function HELPER(cls){
        function ExtendableBuiltin(){
            // Not passing "newTarget" because core-js would fall back to non-exotic
            // object creation.
            var instance = Reflect.construct(cls, Array.from(arguments));
            Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
            return instance;
        }
        ExtendableBuiltin.prototype = Object.create(cls.prototype, {
            constructor: {
                value: cls,
                enumerable: false,
                writable: true,
                configurable: true,
            },
        });
        if (Object.setPrototypeOf){
            Object.setPrototypeOf(ExtendableBuiltin, cls);
        } else {
            ExtendableBuiltin.__proto__ = cls;
        }

        return ExtendableBuiltin;
    }
`);
var buildHelperApproximate = template__default.default(`
    function HELPER(cls){
        function ExtendableBuiltin(){
            cls.apply(this, arguments);
        }
        ExtendableBuiltin.prototype = Object.create(cls.prototype, {
            constructor: {
                value: cls,
                enumerable: false,
                writable: true,
                configurable: true,
            },
        });
        if (Object.setPrototypeOf){
            Object.setPrototypeOf(ExtendableBuiltin, cls);
        } else {
            ExtendableBuiltin.__proto__ = cls;
        }

        return ExtendableBuiltin;
    }
`);
var BuiltinExtendPlugin = helperPluginUtils.declare((api, options) => {
  return {
    name: "storm-stack:builtin-extend",
    visitor: {
      Class(path) {
        const globals = toArray.toArray(options.globals);
        if (!globals.includes("Error")) {
          globals.push("Error");
        }
        const superClass = path.get("superClass");
        if (!superClass?.node || !globals.some((name2) => superClass.isIdentifier({
          name: name2
        }))) {
          return;
        }
        if (path.scope.hasBinding(superClass.node?.name, {
          noGlobals: true
        })) {
          return;
        }
        const name = path.scope.generateUidIdentifier("stormExtendableBuiltin");
        const helper = (this.opts.approximate ? buildHelperApproximate : buildHelper)({
          HELPER: name
        });
        path.scope.getProgramParent().path.unshiftContainer("body", helper);
        superClass.replaceWith(t__namespace.callExpression(name, [
          superClass.node
        ]));
      }
    }
  };
});

exports.BuiltinExtendPlugin = BuiltinExtendPlugin;