src/components/organisms/layout/summary.stories.tsx

Prism.languages.graphql = {
  comment: /#.*/,
  description: {
    pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
    greedy: true,
    alias: 'string',
    inside: {
      'language-markdown': {
        pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
        lookbehind: true,
        inside: Prism.languages.markdown,
      },
    },
  },
  string: {
    pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
    greedy: true,
  },
  number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
  boolean: /\b(?:false|true)\b/,
  variable: /\$[a-z_]\w*/i,
  directive: {
    pattern: /@[a-z_]\w*/i,
    alias: 'function',
  },
  'attr-name': {
    pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
    greedy: true,
  },
  'atom-input': {
    pattern: /\b[A-Z]\w*Input\b/,
    alias: 'class-name',
  },
  scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
  constant: /\b[A-Z][A-Z_\d]*\b/,
  'class-name': {
    pattern:
      /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
    lookbehind: true,
  },
  fragment: {
    pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
    lookbehind: true,
    alias: 'function',
  },
  'definition-mutation': {
    pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
    lookbehind: true,
    alias: 'function',
  },
  'definition-query': {
    pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
    lookbehind: true,
    alias: 'function',
  },
  keyword:
    /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
  operator: /[!=|&]|\.{3}/,
  'property-query': /\w+(?=\s*\()/,
  object: /\w+(?=\s*\{)/,
  punctuation: /[!(){}\[\]:=,]/,
  property: /\w+/,
};

Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {
  if (env.language !== 'graphql') {
    return;
  }

  /**
   * get the graphql token stream that we want to customize
   *
   * @typedef {InstanceType<import("./prism-core")["Token"]>} Token
   * @type {Token[]}
   */
  var validTokens = env.tokens.filter(function (token) {
    return (
      typeof token !== 'string' &&
      token.type !== 'comment' &&
      token.type !== 'scalar'
    );
  });

  var currentIndex = 0;

  /**
   * Returns whether the token relative to the current index has the given type.
   *
   * @param {number} offset
   * @returns {Token | undefined}
   */
  function getToken(offset) {
    return validTokens[currentIndex + offset];
  }

  /**
   * Returns whether the token relative to the current index has the given type.
   *
   * @param {readonly string[]} types
   * @param {number} [offset=0]
   * @returns {boolean}
   */
  function isTokenType(types, offset) {
    offset = offset || 0;
    for (var i = 0; i < types.length; i++) {
      var token = getToken(i + offset);
      if (!token || token.type !== types[i]) {
        return false;
      }
    }
    return true;
  }

  /**
   * Returns the index of the closing bracket to an opening bracket.
   *
   * It is assumed that `token[currentIndex - 1]` is an opening bracket.
   *
   * If no closing bracket could be found, `-1` will be returned.
   *
   * @param {RegExp} open
   * @param {RegExp} close
   * @returns {number}
   */
  function findClosingBracket(open, close) {
    var stackHeight = 1;

    for (var i = currentIndex; i < validTokens.length; i++) {
      var token = validTokens[i];
      var content = token.content;

      if (token.type === 'punctuation' && typeof content === 'string') {
        if (open.test(content)) {
          stackHeight++;
        } else if (close.test(content)) {
          stackHeight--;

          if (stackHeight === 0) {
            return i;
          }
        }
      }
    }

    return -1;
  }

  /**
   * Adds an alias to the given token.
   *
   * @param {Token} token
   * @param {string} alias
   * @returns {void}
   */
  function addAlias(token, alias) {
    var aliases = token.alias;
    if (!aliases) {
      token.alias = aliases = [];
    } else if (!Array.isArray(aliases)) {
      token.alias = aliases = [aliases];
    }
    aliases.push(alias);
  }

  for (; currentIndex < validTokens.length; ) {
    var startToken = validTokens[currentIndex++];

    // add special aliases for mutation tokens
    if (startToken.type === 'keyword' && startToken.content === 'mutation') {
      // any array of the names of all input variables (if any)
      var inputVariables = [];

      if (
        isTokenType(['definition-mutation', 'punctuation']) &&
        getToken(1).content === '('
      ) {
        // definition

        currentIndex += 2; // skip 'definition-mutation' and 'punctuation'

        var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
        if (definitionEnd === -1) {
          continue;
        }

        // find all input variables
        for (; currentIndex < definitionEnd; currentIndex++) {
          var t = getToken(0);
          if (t.type === 'variable') {
            addAlias(t, 'variable-input');
            inputVariables.push(t.content);
          }
        }

        currentIndex = definitionEnd + 1;
      }

      if (
        isTokenType(['punctuation', 'property-query']) &&
        getToken(0).content === '{'
      ) {
        currentIndex++; // skip opening bracket

        addAlias(getToken(0), 'property-mutation');

        if (inputVariables.length > 0) {
          var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
          if (mutationEnd === -1) {
            continue;
          }

          // give references to input variables a special alias
          for (var i = currentIndex; i < mutationEnd; i++) {
            var varToken = validTokens[i];
            if (
              varToken.type === 'variable' &&
              inputVariables.indexOf(varToken.content) >= 0
            ) {
              addAlias(varToken, 'variable-input');
            }
          }
        }
      }
    }
  }
});
	Commit message (Collapse)	Author	Age	Files	Lines
*	refactor: use named export for everything except pages	Armand Philippot	2023-09-20	1	-1/+1
\| \| \| \| \| \|	Next expect a default export for pages so only those components should use default exports. Everything else should use named exports to reduce the number of import statements.
*	refactor: reduce the number of data transformation	Armand Philippot	2022-05-23	1	-24/+4
\|
*	fix: render all images unoptimized in Storybook	Armand Philippot	2022-05-22	1	-1/+0
\| \| \| \| \| \|	There is a bug with next/image and Storybook. I was manually adding `unoptimized` to images. Instead we can use a workaround by adding an extra config in Storybook `preview.js` file.
*	chore: add the Blog index page	Armand Philippot	2022-05-13	1	-13/+10
\|
*	refactor: rewrite DescriptionList and Meta components	Armand Philippot	2022-05-09	1	-22/+11
\| \| \| \| \| \|	The meta can have different layout. The previous implementation was not enough to easily change the layout. Also, I prefer to restrict the meta types and it prevents me to repeat myself for the labels.
*	refactor(storybook): reorganize design system	Armand Philippot	2022-04-20	1	-16/+44
\| \| \| \| \|	Add more stories for each components and change some components categories for better organization.
*	refactor: support React 18	Armand Philippot	2022-04-16	1	-1/+1
\| \| \| \| \| \| \| \|	I replaced the deprecated VFC type with FC type and made all children explicits. Formatjs is still not compatible with React 18 so I need to skip type checking when comitting. There are some type errors because of IntlProvider in Storybook stories.
*	chore: add a Summary component	Armand Philippot	2022-04-12	1	-0/+114