How to use dedent - 10 common examples

apiDetails.forEach(apiDetail => {
    let apiDetailsReturns = "";

    if (apiDetail.returns)
      apiDetailsReturns = JSON.parse(JSON.stringify(apiDetail.returns));

    apiContent.push(`
      <div class="api-content__body">
        <h2 id="${apiDetail.name}">${apiDetail.name}</h2>
        <p>${apiDetail.description}</p>

        ${apiDetail.arguments.length ? `<h3>Arguments</h3><ul class="api-content__body-arguments">${renderArguments(apiDetail.arguments).join("")}</ul>` : ""}
        ${apiDetail.returns ? `<h3>Returns</h3><pre><code>${dedent(apiDetailsReturns)}</code></pre>` : ""}
      </div>

      <div class="api-content__example">
        ${apiDetail.examples &amp;&amp; apiDetail.examples.length ? renderExamples(apiDetail.examples).join("") : `<pre><code>// example(s) for ${apiDetail.name} to come later</code></pre>`}
      </div>
    `);
  });

it('should extract comment comment', () => {
        const input = dedent(`
        import { t } from 'ttag';
        
        //translator: test1
        t\`test\`
        `);
        babel.transform(input, options);
        const result = fs.readFileSync(output).toString();
        expect(result).to.contain('#. test1');
    });

it('should extract t from require', () => {
        const input = dedent(`
        const { t } = require('ttag');
        t\`test\`
        `);
        babel.transform(input, options);
        const result = fs.readFileSync(output).toString();
        expect(result).to.contain('msgid "test"');
    });

it('should extract ngettext', () => {
        const input = dedent(`
            import { c, ngettext, msgid } from 'ttag';
            c('ngettext_ctx').ngettext(msgid\`banana\`, \`bananas\`, n);
        `);
        babel.transform(input, options);
        const result = fs.readFileSync(output).toString();
        expect(result).to.contain('msgctxt "ngettext_ctx"');
        expect(result).to.contain('msgid_plural "bananas"');
    });

it('should extract single comment', () => {
        const input = dedent(`
        import { t } from 'ttag';
        
        //test1
        t\`test\`
        `);
        babel.transform(input, options);
        const result = fs.readFileSync(output).toString();
        expect(result).to.contain('#. test1');
    });

const getBaseScript = (scriptName) => dedent(baseScripts[scriptName].source);

function generator({ artifactTarball, versionTag, license, usePublicArtifact  }) {
  const copyArtifactTarballInsideDockerOptFolder = () => {
    if (usePublicArtifact) {
      return `RUN cd /opt && curl --retry 8 -s -L -O https://artifacts.elastic.co/downloads/kibana/${ artifactTarball } && cd -`;
    }

    return `COPY ${ artifactTarball } /opt`;
  };

  return dedent(`
  #
  # ** THIS IS AN AUTO-GENERATED FILE **
  #

  ################################################################################
  # Build stage 0
  # Extract Kibana and make various file manipulations.
  ################################################################################
  FROM centos:7 AS prep_files
  ${copyArtifactTarballInsideDockerOptFolder()}
  RUN mkdir /usr/share/kibana
  WORKDIR /usr/share/kibana
  RUN tar --strip-components=1 -zxf /opt/${ artifactTarball }
  # Ensure that group permissions are the same as user permissions.
  # This will help when relying on GID-0 to run Kibana, rather than UID-1000.
  # OpenShift does this, for example.

export const CodeSnippet = ({ name, language = "javascript", stripTripleComment = true, dedent = true, transform }) => {
    assert(snippets[name], `Snippet could not be found ${name}`);
    let { content } = snippets[name];
    if (stripTripleComment) content = content.replace(/\s\/\/\/\s/g, " ");
    if (transform) content = transform(content);
    if (dedent) content = dedentStr(content);
    return (
        
            {content}
        
    );
};

var Syncano = require('syncano');
        var connection = Syncano({
          accountKey: '${accountKey}'
        });

        var params = {
          name: '${endpointName}',
          instanceName: 'your_instance',
          socket_name: '${socketName}'
        };

        var endpoint = connection.Endpoint(params);

        endpoint.run(${!isGetMethod ? `'${methodType}', { data: 'something' }` : ''});
      `),
      python: dedent(`
        import syncano
        from syncano.models import Socket

        syncano.connect(api_key="${accountKey}")

        socket = Socket.please.get(instance_name="your_instance", name="${socketName}")
        result = socket.run("${endpointName}"${!isGetMethod ? `, method="${methodType}", data="something"` : ''})
        print result
      `),
      cli: dedent(`
        syncano sockets run ${socketName}/${endpointName} ${!isGetMethod ? `${methodType} -d data=something` : ''}
      `)
    };

    const formatedExample = examplesLang[language];

render(h) {
        return h(InfoView, {
          props: {
            storyKind: context.kind,
            storyTitle: context.story,
            summary: marked(dedent(opts.summary)),
            template: dedent(
              story.template || getJSXFromRenderFn(story.render! as any)
            ),
            lang: story.template ? 'html' : 'jsx',
            componentDetails,
            showHeader: opts.header,
            showSource: opts.source,
            userStyle: opts.styles
          },
          scopedSlots: {
            default: () => [h(story)]
          }
        })
      }
    }