Sync preprocess

src/modules/markup.ts

@@ -1,10 +1,12 @@
+import pipe, { EventuallyProcessed } from '../pipe';
 import { Transformer, Preprocessor } from '../types';
 
-export async function transformMarkup(
+export function transformMarkup<S>(
+  sync: S,
   { content, filename }: { content: string; filename: string },
   transformer: Preprocessor | Transformer<unknown>,
   options: Record<string, any> = {},
-) {
+): EventuallyProcessed<S> {
   let { markupTagName = 'template' } = options;
 
   markupTagName = markupTagName.toLocaleLowerCase();
@@ -17,7 +19,12 @@ export async function transformMarkup(
 
   /** If no <template> was found, run the transformer over the whole thing */
   if (!templateMatch) {
-    return transformer({ content, attributes: {}, filename, options });
+    return transformer({
+      content,
+      attributes: {},
+      filename,
+      options,
+    }) as EventuallyProcessed<S>;
   }
 
   const [fullMatch, attributesStr, templateCode] = templateMatch;
@@ -36,17 +43,22 @@ export async function transformMarkup(
     }, {});
 
   /** Transform the found template code */
-  let { code, map, dependencies } = await transformer({
-    content: templateCode,
-    attributes,
-    filename,
-    options,
-  });
-
-  code =
-    content.slice(0, templateMatch.index) +
-    code +
-    content.slice(templateMatch.index + fullMatch.length);
-
-  return { code, map, dependencies };
+  return pipe<S>(
+    sync,
+    () =>
+      transformer({
+        content: templateCode,
+        attributes,
+        filename,
+        options,
+      }) as EventuallyProcessed<S>,
+    ({ code, map, dependencies }) => {
+      code =
+        content.slice(0, templateMatch.index) +
+        code +
+        content.slice(templateMatch.index + fullMatch.length);
+
+      return { code, map, dependencies } as EventuallyProcessed<S>;
+    },
+  );
 }

src/modules/tagInfo.ts

@@ -1,4 +1,4 @@
-import { readFile, access } from 'fs';
+import { readFile, access, accessSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 
 import { PreprocessorArgs } from '../types';
@@ -18,10 +18,68 @@ const getSrcContent = (file: string): Promise<string> => {
   });
 };
 
+const getSrcContentSync = (file: string) => {
+  const data = readFileSync(file);
+
+  return data.toString();
+};
+
 async function doesFileExist(file: string) {
   return new Promise((resolve) => access(file, 0, (err) => resolve(!err)));
 }
 
+function doesFileExistSync(file: string) {
+  try {
+    accessSync(file, 0);
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export const getTagInfoSync = ({
+  attributes,
+  filename,
+  content,
+}: PreprocessorArgs) => {
+  const dependencies = [];
+  // catches empty content and self-closing tags
+  const isEmptyContent = content == null || content.trim().length === 0;
+
+  /** only include src file if content of tag is empty */
+  if (attributes.src && isEmptyContent) {
+    // istanbul ignore if
+    if (typeof attributes.src !== 'string') {
+      throw new Error('src attribute must be string');
+    }
+
+    let path = attributes.src;
+
+    /** Only try to get local files (path starts with ./ or ../) */
+    if (isValidLocalPath(path)) {
+      path = resolveSrc(filename, path);
+      if (doesFileExistSync(path)) {
+        content = getSrcContentSync(path);
+        dependencies.push(path);
+      } else {
+        console.warn(`[svelte-preprocess] The file  "${path}" was not found.`);
+      }
+    }
+  }
+
+  const { lang, alias } = getLanguage(attributes);
+
+  return {
+    filename,
+    attributes,
+    content,
+    lang,
+    alias,
+    dependencies,
+  };
+};
+
 export const getTagInfo = async ({
   attributes,
   filename,

src/modules/utils.ts

@@ -39,15 +39,15 @@ const cachedResult: Record<string, boolean> = {};
  * @param {string} dep
  * @returns boolean
  */
-export async function hasDepInstalled(dep: string) {
+export function hasDepInstalled(dep: string) {
   if (cachedResult[dep] != null) {
     return cachedResult[dep];
   }
 
   let result = false;
 
   try {
-    await import(dep);
+    require(dep);
 
     result = true;
   } catch (e) {

src/pipe.ts

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { Processed } from './types';
+
+export type EventuallyProcessed<Sync> = Sync extends true
+  ? Processed
+  : Processed | Promise<Processed>;
+
+const pipe: <Sync>(
+  sync: Sync,
+  start: () => EventuallyProcessed<Sync>,
+  ...then: Array<(processed: Processed) => EventuallyProcessed<Sync>>
+) => EventuallyProcessed<Sync> = (sync, start, ...then) =>
+  ((sync ? pipe_sync : pipe_async) as any)(start, ...then);
+
+async function pipe_async(
+  start: () => Promise<Processed>,
+  ...then: Array<(processed: Processed) => Promise<Processed>>
+) {
+  let processed = await start();
+
+  for (let i = 0; i < then.length; i++) {
+    // eslint-disable-next-line no-await-in-loop
+    processed = await then[i](processed);
+  }
+
+  return processed;
+}
+
+function pipe_sync(
+  start: () => Processed,
+  ...then: Array<(processed: Processed) => Processed>
+) {
+  let processed = start();
+
+  for (let i = 0; i < then.length; i++) {
+    processed = then[i](processed);
+  }
+
+  return processed;
+}
+
+export default pipe;

src/processors/pug.ts

@@ -15,6 +15,25 @@ export default (options?: Options.Pug): PreprocessorGroup => ({
       content,
     });
 
-    return transformMarkup({ content, filename }, transformer, options);
+    return transformMarkup(false, { content, filename }, transformer, options);
+  },
+
+  markup_sync({ content, filename }) {
+    const { transformer } = require('../transformers/pug');
+
+    content = prepareContent({
+      options: {
+        ...options,
+        stripIndent: true,
+      },
+      content,
+    });
+
+    return transformMarkup<true>(
+      true,
+      { content, filename },
+      transformer,
+      options,
+    );
   },
 });

src/processors/typescript.ts

@@ -1,26 +1,22 @@
 import { Options, PreprocessorGroup } from '../types';
-import { getTagInfo } from '../modules/tagInfo';
+import { getTagInfoSync } from '../modules/tagInfo';
 import { concat } from '../modules/utils';
 import { prepareContent } from '../modules/prepareContent';
 
-export default (options?: Options.Typescript): PreprocessorGroup => ({
-  async script(svelteFile) {
-    const { transformer } = await import('../transformers/typescript');
-    let {
-      content,
-      filename,
-      attributes,
-      lang,
-      dependencies,
-    } = await getTagInfo(svelteFile);
+export default (options?: Options.Typescript): PreprocessorGroup => {
+  const script = (svelteFile) => {
+    const { transformer } = require('../transformers/typescript');
+    let { content, filename, attributes, lang, dependencies } = getTagInfoSync(
+      svelteFile,
+    );
 
     content = prepareContent({ options, content });
 
     if (lang !== 'typescript') {
       return { code: content };
     }
 
-    const transformed = await transformer({
+    const transformed = transformer({
       content,
       filename,
       attributes,
@@ -31,5 +27,10 @@ export default (options?: Options.Typescript): PreprocessorGroup => ({
       ...transformed,
       dependencies: concat(dependencies, transformed.dependencies),
     };
-  },
-});
+  };
+
+  return {
+    script,
+    script_sync: script,
+  };
+};

src/transformers/replace.ts

@@ -1,9 +1,7 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { Transformer, Options } from '../types';
 
-const transformer: Transformer<Options.Replace> = async ({
-  content,
-  options,
-}) => {
+const transformer: Transformer<Options.Replace> = ({ content, options }) => {
   let newContent = content;
 
   for (const [regex, replacer] of options) {
@@ -15,4 +13,6 @@ const transformer: Transformer<Options.Replace> = async ({
   };
 };
 
-export { transformer };
+const is_sync = true;
+
+export { transformer, is_sync };

src/transformers/typescript.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { dirname } from 'path';
 
 import ts from 'typescript';
@@ -151,4 +152,6 @@ const transformer: Transformer<Options.Typescript> = ({
   };
 };
 
-export { transformer };
+const is_sync = true;
+
+export { transformer, is_sync };

src/types/index.ts

@@ -34,6 +34,8 @@ export type Transformer<T> = (
   args: TransformerArgs<T>,
 ) => Processed | Promise<Processed>;
 
+export type SyncTransformer<T> = (args: TransformerArgs<T>) => Processed;
+
 export type TransformerOptions<T = any> = boolean | T | Transformer<T>;
 
 export interface Transformers {

test/autoProcess/externalFiles.test.ts

@@ -32,6 +32,7 @@ describe('external files', () => {
         <style src="./fixtures/style.css"></style>
         <script src="./fixtures/script.js"></script>`,
         filename: resolve(__dirname, '..', 'App.svelte'),
+        attributes: {},
       }),
       await scriptProcessor({
         content: ``,
@@ -57,6 +58,7 @@ describe('external files', () => {
     const markup = await markupProcessor({
       content: `<template src="./fixtures/template.html"/>`,
       filename: resolve(__dirname, '..', 'App.svelte'),
+      attributes: {},
     });
 
     expect(markup.code).toContain(getFixtureContent('template.html'));