@fisker/prettier-config/dist/index.js

fisker's Shareable prettier Configuration

'use strict';

const config$e = {
  bracketSpacing: false,
  htmlWhitespaceSensitivity: 'ignore',
  semi: false,
  singleQuote: true,
  trailingComma: 'all',
};

const config$d = {
  singleQuote: false,
};

const config$c = {};

const config$b = {
  // effect js in html
  singleQuote: true,
};

const config$a = {
  parser: 'babel',
  singleQuote: true,
};

const config$9 = {
  parser: 'json-stringify',
  singleQuote: false,
};

const config$8 = {
  singleQuote: false,
};

const config$7 = {
  singleQuote: false,
};

const config$6 = {
  singleQuote: true,
};

const config$5 = {};

const config$4 = {
  singleQuote: false,
};

const config$3 = {
  singleQuote: true,
};

const config$2 = {};

const config$1 = {
  singleQuote: false,
};

var languages = /*#__PURE__*/Object.freeze({
  __proto__: null,
  css: config$d,
  graphql: config$c,
  html: config$b,
  javascript: config$a,
  json: config$9,
  json5: config$8,
  less: config$7,
  markdown: config$6,
  mdx: config$5,
  scss: config$4,
  typescript: config$3,
  vue: config$2,
  yaml: config$1
});

function toArray(array) {
  array = Array.isArray(array) ? array : String(array).split(',');
  return array.map((item) => item.trim()).filter(Boolean)
}

const languageExtensions = {
  graphql: 'gql,graphql',
  html: 'html,htm',
  javascript: 'js,jsx,mjs,cjs',
  // more markdown extensions: mdown, mdwn, mkd, mkdn, mkdown
  markdown: 'md,markdown',
  typescript: 'ts,tsx,mts,cts',
  yaml: 'yaml,yml',
};

function getExtensions(language) {
  return toArray(languageExtensions[language] || language)
}

function isUndefined(x) {
  return x === undefined
}

// https://prettier.io/docs/en/options.html
const SUPPORTED_OPTIONS = [
  'printWidth',
  'tabWidth',
  'useTabs',
  'semi',
  'singleQuote',
  'quoteProps',
  'jsxSingleQuote',
  'trailingComma',
  'bracketSpacing',
  'jsxBracketSameLine',
  'arrowParens',
  'rangeStart',
  'rangeEnd',
  'parser',
  'filepath',
  'requirePragma',
  'insertPragma',
  'proseWrap',
  'htmlWhitespaceSensitivity',
  'endOfLine',
];

function toGlob(extensions) {
  return extensions.length > 1
    ? `*.{${extensions.sort().join(',')}}`
    : `*.${extensions}`
}

function isGlobalConfig(key, value) {
  const globalValue = config$e[key];

  return globalValue === value
}

function toOverride({extensions, config}) {
  const files = toGlob(extensions);

  const options = Object.fromEntries(
    SUPPORTED_OPTIONS.map((key) => [key, config[key]]).filter(
      ([key, value]) => !isUndefined(value) && !isGlobalConfig(key, value),
    ),
  );

  return {
    files,
    options,
  }
}

function toOverrides(languages) {
  return Object.keys(languages).map((language) =>
    toOverride({
      extensions: getExtensions(language),
      config: {
        parser: language,
        ...languages[language],
      },
    }),
  )
}

const config = {
  ...config$e,
  overrides: [...toOverrides(languages)],
};

const defaults = {enumerable: true, writable: true, configurable: true};

function defineProperty(object, key, value, options = {}) {
  return Object.defineProperty(object, key, {
    ...defaults,
    value,
    ...options,
  })
}

function defineProperties(object, properties, options = {}) {
  for (const [key, value] of Object.entries(properties)) {
    defineProperty(object, key, value, options);
  }

  return object
}

class Configuration {
  constructor(options = {}) {
    this.options = options;
  }

  extend(customize = {}) {
    const {options} = this;
    const {overrides = []} = options;

    const {overrides: customizeOverrides = []} = customize;

    const extended = {
      ...options,
      ...customize,
      overrides: [...overrides, ...customizeOverrides],
    };

    return getConfig(extended)
  }

  get config() {
    const {options} = this;
    const {overrides = []} = options;

    const config = {
      ...options,
    };

    if (overrides.length !== 0) {
      config.overrides = [...overrides];
    }

    const {extend} = Configuration.prototype;

    return defineProperties(
      config,
      {
        extend: extend.bind(this),
      },
      {
        enumerable: false,
      },
    )
  }
}

function getConfig(options = config) {
  return new Configuration(options).config
}

var index = getConfig(config);

module.exports = index;