@pdfme/ui 5.5.10-dev.11 → 5.5.10-dev.125

package/src/components/Designer/index.tsx

@@ -1,4 +1,4 @@
-import React, { useRef, useState, useContext, useCallback, useEffect } from 'react';
+import React, { useRef, useState, useContext, useCallback, useEffect, useLayoutEffect } from 'react';
 import {
   cloneDeep,
   ZOOM,
@@ -72,6 +72,7 @@ const TemplateEditor = ({
   const [pageCursor, setPageCursor] = useState(0);
   const [zoomLevel, setZoomLevel] = useState(options.zoomLevel ?? 1);
   const [sidebarOpen, setSidebarOpen] = useState(options.sidebarOpen ?? true);
+  const [canvasHeight, setCanvasHeight] = useState(0);
   const [prevTemplate, setPrevTemplate] = useState<Template | null>(null);
 
   const { backgrounds, pageSizes, scale, error, refresh } = useUIPreProcessor({
@@ -81,8 +82,8 @@ const TemplateEditor = ({
     maxZoom,
   });
 
-  const onEdit = (targets: HTMLElement[]) => {
-    setActiveElements(targets);
+  const onEdit = (targets: Array<HTMLElement | null | undefined>) => {
+    setActiveElements(targets.filter((target): target is HTMLElement => target instanceof HTMLElement));
     setHoveringSchemaId(null);
   };
 
@@ -91,17 +92,17 @@ const TemplateEditor = ({
     setHoveringSchemaId(null);
   };
 
-  // Update component state only when _options_ changes
-  // Ignore exhaustive useEffect dependency warnings here
   useEffect(() => {
-    if (typeof options.zoomLevel === 'number' && options.zoomLevel !== zoomLevel) {
+    if (typeof options.zoomLevel === 'number') {
       setZoomLevel(options.zoomLevel);
     }
-    if (typeof options.sidebarOpen === 'boolean' && options.sidebarOpen !== sidebarOpen) {
+  }, [options.zoomLevel]);
+
+  useEffect(() => {
+    if (typeof options.sidebarOpen === 'boolean') {
       setSidebarOpen(options.sidebarOpen);
     }
-    // eslint-disable-next-line
-  }, [options]);
+  }, [options.sidebarOpen]);
 
   useScrollPageCursor({
     ref: canvasRef,
@@ -115,6 +116,20 @@ const TemplateEditor = ({
     },
   });
 
+  useLayoutEffect(() => {
+    const updateHeight = () => {
+      setCanvasHeight(canvasRef.current ? canvasRef.current.clientHeight : 0);
+    };
+    updateHeight();
+
+    if (typeof ResizeObserver === 'function' && canvasRef.current) {
+      const observer = new ResizeObserver(updateHeight);
+      observer.observe(canvasRef.current);
+      return () => observer.disconnect();
+    }
+    return undefined;
+  }, [scale]);
+
   const commitSchemas = useCallback(
     (newSchemas: SchemaForUI[]) => {
       future.current = [];
@@ -222,7 +237,7 @@ const TemplateEditor = ({
     }
 
     commitSchemas(schemasList[pageCursor].concat(s));
-    setTimeout(() => onEdit([document.getElementById(s.id)!]));
+    setTimeout(() => onEdit([document.getElementById(s.id)]));
   };
 
   const onSortEnd = (sortedSchemas: SchemaForUI[]) => {
@@ -239,7 +254,7 @@ const TemplateEditor = ({
     onChangeTemplate(newTemplate);
     await updateTemplate(newTemplate);
     void refresh(newTemplate);
-    
+
     // Notify page change with updated total pages
     onPageCursorChange(newPageCursor, sl.length);
 
@@ -313,11 +328,7 @@ const TemplateEditor = ({
         }}
         onDragStart={onEditEnd}
       >
-        <LeftSidebar
-          height={canvasRef.current ? canvasRef.current.clientHeight : 0}
-          scale={scale}
-          basePdf={template.basePdf}
-        />
+        <LeftSidebar height={canvasHeight} scale={scale} basePdf={template.basePdf} />
 
         <div style={{ position: 'absolute', width: canvasWidth, marginLeft: LEFT_SIDEBAR_WIDTH }}>
           <CtlBar
@@ -340,7 +351,7 @@ const TemplateEditor = ({
           <RightSidebar
             hoveringSchemaId={hoveringSchemaId}
             onChangeHoveringSchemaId={onChangeHoveringSchemaId}
-            height={canvasRef.current ? canvasRef.current.clientHeight : 0}
+            height={canvasHeight}
             size={size}
             pageSize={pageSizes[pageCursor] ?? []}
             basePdf={template.basePdf}

package/src/components/Preview.tsx

@@ -1,4 +1,4 @@
-import React, { useRef, useState, useEffect, useContext } from 'react';
+import React, { useRef, useState, useEffect, useContext, useCallback } from 'react';
 import {
   Template,
   SchemaForUI,
@@ -7,7 +7,7 @@ import {
   getDynamicTemplate,
   replacePlaceholders,
 } from '@pdfme/common';
-import { getDynamicHeightsForTable } from '@pdfme/schemas/utils';
+import { getDynamicHeightsForTable } from '@pdfme/schemas/tables';
 import UnitPager from './UnitPager.js';
 import Root from './Root.js';
 import StaticSchema from './StaticSchema.js';
@@ -57,10 +57,36 @@ const Preview = ({
   const isForm = Boolean(onChangeInput);
 
   const input = inputs[unitCursor];
+  const latestFontRef = useRef(font);
+  const latestInputRef = useRef(input);
+  const latestRefreshRef = useRef(refresh);
+  const isMountedRef = useRef(true);
+  const initRequestIdRef = useRef(0);
 
-  const init = (template: Template, inputOverride?: Record<string, string>) => {
-    const currentInput = inputOverride ?? input;
-    const options = { font };
+  useEffect(() => {
+    latestFontRef.current = font;
+  }, [font]);
+
+  useEffect(() => {
+    latestInputRef.current = input;
+  }, [input]);
+
+  useEffect(() => {
+    latestRefreshRef.current = refresh;
+  }, [refresh]);
+
+  useEffect(
+    () => () => {
+      isMountedRef.current = false;
+    },
+    [],
+  );
+
+  const init = useCallback((template: Template, inputOverride?: Record<string, string>) => {
+    const requestId = ++initRequestIdRef.current;
+    const currentInput = inputOverride ?? latestInputRef.current;
+    const options = { font: latestFontRef.current };
+    const currentRefresh = latestRefreshRef.current;
     getDynamicTemplate({
       template,
       input: currentInput,
@@ -77,28 +103,28 @@ const Preview = ({
     })
       .then(async (dynamicTemplate) => {
         const sl = await template2SchemasList(dynamicTemplate);
+        if (!isMountedRef.current || requestId !== initRequestIdRef.current) {
+          return;
+        }
         setSchemasList(sl);
-        await refresh(dynamicTemplate);
+        await currentRefresh(dynamicTemplate);
       })
       .catch((err) => console.error(`[@pdfme/ui] `, err));
-  };
+  }, []);
 
-  // Update component state only when _options_ changes
-  // Ignore exhaustive useEffect dependency warnings here
   useEffect(() => {
-    if (typeof options.zoomLevel === 'number' && options.zoomLevel !== zoomLevel) {
+    if (typeof options.zoomLevel === 'number') {
       setZoomLevel(options.zoomLevel);
     }
-    // eslint-disable-next-line
-  }, [options]);
+  }, [options.zoomLevel]);
 
   useEffect(() => {
     if (unitCursor > inputs.length - 1) {
       setUnitCursor(inputs.length - 1);
+      return;
     }
-
     init(template);
-  }, [template, inputs, size]);
+  }, [init, inputs, size, template, unitCursor]);
 
   useScrollPageCursor({
     ref: containerRef,

package/src/components/Renderer.tsx

@@ -36,7 +36,7 @@ type ReRenderCheckProps = {
   options: UIOptions;
 };
 
-const useRerenderDependencies = (arg: ReRenderCheckProps) => {
+const useRenderKey = (arg: ReRenderCheckProps) => {
   const { plugin, value, mode, scale, schema, options } = arg;
   const _options = cloneDeep(options);
   if (_options.font) {
@@ -48,9 +48,9 @@ const useRerenderDependencies = (arg: ReRenderCheckProps) => {
 
   return useMemo(() => {
     if (plugin?.uninterruptedEditMode && mode === 'designer') {
-      return [mode];
+      return mode;
     } else {
-      return [value, mode, scale, JSON.stringify(schema), optionStr];
+      return JSON.stringify([value, mode, scale, schema, optionStr]);
     }
   }, [value, mode, scale, schema, optionStr, plugin]);
 };
@@ -110,8 +110,41 @@ const Renderer = (props: RendererProps) => {
   const ref = useRef<HTMLDivElement>(null);
   const _cache = useContext(CacheContext);
   const plugin = pluginsRegistry.findByType(schema.type);
+  const renderArgsRef = useRef({
+    plugin,
+    value,
+    schema,
+    basePdf,
+    mode,
+    onChange,
+    stopEditing,
+    tabIndex,
+    placeholder,
+    options,
+    theme,
+    i18n,
+    scale,
+    _cache,
+  });
 
-  const reRenderDependencies = useRerenderDependencies({
+  renderArgsRef.current = {
+    plugin,
+    value,
+    schema,
+    basePdf,
+    mode,
+    onChange,
+    stopEditing,
+    tabIndex,
+    placeholder,
+    options,
+    theme,
+    i18n,
+    scale,
+    _cache,
+  };
+
+  const renderKey = useRenderKey({
     plugin,
     value,
     mode,
@@ -121,34 +154,47 @@ const Renderer = (props: RendererProps) => {
   });
 
   useEffect(() => {
-    if (!plugin?.ui || !ref.current || !schema.type) return;
-
-    ref.current.innerHTML = '';
-    const render = plugin.ui;
-
-    void render({
-      value,
-      schema,
-      basePdf,
-      rootElement: ref.current,
-      mode,
-      onChange,
-      stopEditing,
-      tabIndex,
-      placeholder,
-      options,
-      theme,
-      i18n,
-      scale,
-      _cache,
+    const element = ref.current;
+    const renderArgs = renderArgsRef.current;
+    if (!renderArgs.plugin?.ui || !element || !schema.type) return;
+
+    let cancelled = false;
+    element.innerHTML = '';
+    element.dataset.pdfmeRenderReady = 'false';
+    const render = renderArgs.plugin.ui;
+
+    void Promise.resolve(
+      render({
+        value: renderArgs.value,
+        schema: renderArgs.schema,
+        basePdf: renderArgs.basePdf,
+        rootElement: element,
+        mode: renderArgs.mode,
+        onChange: renderArgs.onChange,
+        stopEditing: renderArgs.stopEditing,
+        tabIndex: renderArgs.tabIndex,
+        placeholder: renderArgs.placeholder,
+        options: renderArgs.options,
+        theme: renderArgs.theme,
+        i18n: renderArgs.i18n,
+        scale: renderArgs.scale,
+        _cache: renderArgs._cache,
+      }),
+    ).finally(() => {
+      if (!cancelled) {
+        element.dataset.pdfmeRenderReady = 'true';
+      }
     });
 
     return () => {
-      if (ref.current) {
-        ref.current.innerHTML = '';
+      cancelled = true;
+      if (element) {
+        element.dispatchEvent(new Event('beforeRemove'));
+        element.innerHTML = '';
+        delete element.dataset.pdfmeRenderReady;
       }
     };
-  }, reRenderDependencies);
+  }, [renderKey, schema.type]);
 
   if (!plugin) {
     console.error(`[@pdfme/ui] Renderer for type ${schema.type} not found. 

package/src/components/Root.tsx

@@ -29,8 +29,14 @@ const Root = ({ size, scale, children }: Props, ref: Ref<HTMLDivElement>) => {
   }, [font]);
 
   return (
-    <div className={DESIGNER_CLASSNAME + 'root'} ref={ref} style={{ position: 'relative', background: BACKGROUND_COLOR, ...size }}>
-      <div className={DESIGNER_CLASSNAME + 'background'} style={{ margin: '0 auto', ...size }}>{scale === 0 ? <Spinner /> : children}</div>
+    <div
+      className={DESIGNER_CLASSNAME + 'root'}
+      ref={ref}
+      style={{ position: 'relative', background: BACKGROUND_COLOR, ...size }}
+    >
+      <div className={DESIGNER_CLASSNAME + 'background'} style={{ margin: '0 auto', ...size }}>
+        {scale === 0 ? <Spinner /> : children}
+      </div>
     </div>
   );
 };

package/src/contexts.ts

@@ -1,7 +1,7 @@
 import { createContext } from 'react';
 import { i18n } from './i18n.js';
 import { getDefaultFont, PluginRegistry, pluginRegistry, UIOptions } from '@pdfme/common';
-import { builtInPlugins } from '@pdfme/schemas';
+import { builtInPlugins } from '@pdfme/schemas/builtins';
 
 export const I18nContext = createContext(i18n);
 

package/src/helper.ts

@@ -301,7 +301,7 @@ export const template2SchemasList = async (_template: Template) => {
 
   return (
     ssl < psl
-      ? schemasForUI.concat(new Array(psl - ssl).fill(cloneDeep([])))
+      ? schemasForUI.concat(Array.from({ length: psl - ssl }, () => cloneDeep([])))
       : schemasForUI.slice(0, pageSizes.length)
   ).map((schema, i) => {
     Object.values(schema).forEach((value) => {

package/src/hooks.ts

@@ -42,81 +42,108 @@ export const useUIPreProcessor = ({ template, size, zoomLevel, maxZoom }: UIPreP
   const [pageSizes, setPageSizes] = useState<Size[]>([]);
   const [scale, setScale] = useState(0);
   const [error, setError] = useState<Error | null>(null);
+  const isMountedRef = useRef(true);
+  const requestIdRef = useRef(0);
+
+  const init = useCallback(
+    async (prop: { template: Template; size: Size }) => {
+      const {
+        template: { basePdf, schemas },
+        size,
+      } = prop;
+
+      let paperWidth: number;
+      let paperHeight: number;
+      let _backgrounds: string[];
+      let _pageSizes: { width: number; height: number }[];
+
+      if (isBlankPdf(basePdf)) {
+        const { width, height } = basePdf;
+        paperWidth = width * ZOOM;
+        paperHeight = height * ZOOM;
+        _backgrounds = schemas.map(
+          () =>
+            'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdj+P///38ACfsD/QVDRcoAAAAASUVORK5CYII=',
+        );
+        _pageSizes = schemas.map(() => ({ width, height }));
+      } else {
+        const _basePdf = await getB64BasePdf(basePdf);
+        const uint8Array = b64toUint8Array(_basePdf);
+        const createPdfArrayBuffer = () => {
+          const buffer = new ArrayBuffer(uint8Array.byteLength);
+          new Uint8Array(buffer).set(uint8Array);
+          return buffer;
+        };
+
+        const [pageSizeBuffer, imageBuffer] = [createPdfArrayBuffer(), createPdfArrayBuffer()];
+        const [_pages, imgBuffers] = await Promise.all([
+          pdf2size(pageSizeBuffer),
+          pdf2img(imageBuffer, { scale: maxZoom }),
+        ]);
+        _pageSizes = _pages;
+        paperWidth = _pageSizes[0].width * ZOOM;
+        paperHeight = _pageSizes[0].height * ZOOM;
+        _backgrounds = imgBuffers.map(arrayBufferToBase64);
+      }
 
-  const init = async (prop: { template: Template; size: Size }) => {
-    const {
-      template: { basePdf, schemas },
-      size,
-    } = prop;
-
-    let paperWidth: number;
-    let paperHeight: number;
-    let _backgrounds: string[];
-    let _pageSizes: { width: number; height: number }[];
-
-    if (isBlankPdf(basePdf)) {
-      const { width, height } = basePdf;
-      paperWidth = width * ZOOM;
-      paperHeight = height * ZOOM;
-      _backgrounds = schemas.map(
-        () =>
-          'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdj+P///38ACfsD/QVDRcoAAAAASUVORK5CYII=',
+      const _scale = Math.min(
+        getScale(size.width, paperWidth),
+        getScale(size.height - RULER_HEIGHT, paperHeight),
       );
-      _pageSizes = schemas.map(() => ({ width, height }));
-    } else {
-      const _basePdf = await getB64BasePdf(basePdf);
-
-      const uint8Array = b64toUint8Array(_basePdf);
-      // Create a new ArrayBuffer copy to avoid detachment issues
-      const pdfArrayBuffer = new ArrayBuffer(uint8Array.byteLength);
-      new Uint8Array(pdfArrayBuffer).set(uint8Array);
-
-      const [_pages, imgBuffers] = await Promise.all([
-        pdf2size(pdfArrayBuffer),
-        pdf2img(pdfArrayBuffer.slice(), { scale: maxZoom }),
-      ]);
-      _pageSizes = _pages;
-      paperWidth = _pageSizes[0].width * ZOOM;
-      paperHeight = _pageSizes[0].height * ZOOM;
-      _backgrounds = imgBuffers.map(arrayBufferToBase64);
-    }
-
-    const _scale = Math.min(
-      getScale(size.width, paperWidth),
-      getScale(size.height - RULER_HEIGHT, paperHeight),
-    );
 
-    return {
-      backgrounds: _backgrounds,
-      pageSizes: _pageSizes,
-      scale: _scale,
-    };
-  };
+      return {
+        backgrounds: _backgrounds,
+        pageSizes: _pageSizes,
+        scale: _scale,
+      };
+    },
+    [maxZoom],
+  );
+
+  useEffect(
+    () => () => {
+      isMountedRef.current = false;
+    },
+    [],
+  );
+
+  const runInit = useCallback(
+    async (prop: { template: Template; size: Size }) => {
+      const requestId = ++requestIdRef.current;
+
+      try {
+        const { pageSizes, scale, backgrounds } = await init(prop);
+        if (!isMountedRef.current || requestId !== requestIdRef.current) {
+          return;
+        }
 
-  useEffect(() => {
-    init({ template, size })
-      .then(({ pageSizes, scale, backgrounds }) => {
         setPageSizes(pageSizes);
         setScale(scale);
         setBackgrounds(backgrounds);
-      })
-      .catch((err: Error) => {
-        setError(err);
-        console.error('[@pdfme/ui]', err);
-      });
-  }, [template, size]);
+        setError(null);
+      } catch (err: unknown) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (isMountedRef.current && requestId === requestIdRef.current) {
+          setError(error);
+          console.error('[@pdfme/ui]', error);
+        }
+      }
+    },
+    [init],
+  );
+
+  useEffect(() => {
+    void runInit({ template, size });
+  }, [runInit, template, size]);
+
+  const refresh = useCallback((template: Template) => runInit({ template, size }), [runInit, size]);
 
   return {
     backgrounds,
     pageSizes,
     scale: scale * zoomLevel,
     error,
-    refresh: (template: Template) =>
-      init({ template, size }).then(({ pageSizes, scale, backgrounds }) => {
-        setPageSizes(pageSizes);
-        setScale(scale);
-        setBackgrounds(backgrounds);
-      }),
+    refresh,
   };
 };
 
@@ -164,10 +191,11 @@ export const useScrollPageCursor = ({
   }, [onChangePageCursor, pageCursor, pageSizes, ref, scale]);
 
   useEffect(() => {
-    ref.current?.addEventListener('scroll', onScroll);
+    const node = ref.current;
+    node?.addEventListener('scroll', onScroll);
 
     return () => {
-      ref.current?.removeEventListener('scroll', onScroll);
+      node?.removeEventListener('scroll', onScroll);
     };
   }, [ref, onScroll]);
 };
@@ -196,7 +224,7 @@ interface UseInitEventsParams {
   past: React.MutableRefObject<SchemaForUI[][]>;
   future: React.MutableRefObject<SchemaForUI[][]>;
   setSchemasList: React.Dispatch<React.SetStateAction<SchemaForUI[][]>>;
-  onEdit: (targets: HTMLElement[]) => void;
+  onEdit: (targets: Array<HTMLElement | null | undefined>) => void;
   onEditEnd: () => void;
 }
 
@@ -219,6 +247,11 @@ export const useInitEvents = ({
   const copiedSchemas = useRef<SchemaForUI[] | null>(null);
 
   const initEvents = useCallback(() => {
+    const getElementsByIds = (ids: string[]) =>
+      ids
+        .map((id) => document.getElementById(id))
+        .filter((element): element is HTMLElement => element instanceof HTMLElement);
+
     const getActiveSchemas = () => {
       const ids = activeElements.map((ae) => ae.id);
 
@@ -267,7 +300,9 @@ export const useInitEvents = ({
           return Object.assign(cloneDeep(cs), { id, name, position });
         });
         commitSchemas(schemasList[pageCursor].concat(pasteSchemas));
-        onEdit(pasteSchemas.map((s) => document.getElementById(s.id)!));
+        setTimeout(() => {
+          onEdit(getElementsByIds(pasteSchemas.map((s) => s.id)));
+        });
         copiedSchemas.current = pasteSchemas;
       },
       redo: () => timeTravel('redo'),
@@ -276,7 +311,7 @@ export const useInitEvents = ({
         onSaveTemplate && onSaveTemplate(schemasList2template(schemasList, template.basePdf)),
       remove: () => removeSchemas(getActiveSchemas().map((s) => s.id)),
       esc: onEditEnd,
-      selectAll: () => onEdit(schemasList[pageCursor].map((s) => document.getElementById(s.id)!)),
+      selectAll: () => onEdit(getElementsByIds(schemasList[pageCursor].map((s) => s.id))),
     });
   }, [
     template,

package/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.build.base.json",
+  "compilerOptions": {
+    "jsx": "react",
+    "declaration": true,
+    "declarationDir": "./dist",
+    "emitDeclarationOnly": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/tsconfig.json

@@ -1,48 +1,13 @@
 {
+  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "noImplicitAny": true,
-    "target": "ES2020",
     "jsx": "react",
-    "esModuleInterop": true,
-    "isolatedModules": true,
-    "declaration": true,
-    "declarationDir": "dist/types",
     "module": "ESNext",
-    "lib": [
-      "ES2020",
-      "DOM",
-      "DOM.Iterable",
-      "ESNext"
-    ],
     "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "types": ["jest"],
-    "typeRoots": [
-      "../node_modules/@types",
-      "./node_modules/@types",
-      "../../node_modules/@types"
-    ],
-    "sourceMap": true,
-    "baseUrl": ".",
-    "paths": {
-      "@pdfme/common": [
-        "packages/common/dist/esm/src"
-      ],
-      "@pdfme/schemas": [
-        "packages/schemas/dist/esm/src"
-      ]
-    },
+    "noEmit": true,
+    "typeRoots": ["../node_modules/@types", "./node_modules/@types", "../../node_modules/@types"],
     "skipLibCheck": true
   },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "__tests__/**/*.ts",
-    "__tests__/**/*.tsx"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
 }

package/tsconfig.typecheck.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "jsx": "react",
+    "declaration": true,
+    "declarationDir": "dist/typecheck",
+    "emitDeclarationOnly": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist/typecheck",
+    "tsBuildInfoFile": "dist/typecheck/tsconfig.tsbuildinfo",
+    "typeRoots": ["../node_modules/@types", "./node_modules/@types", "../../node_modules/@types"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../common" }, { "path": "../converter" }, { "path": "../schemas" }]
+}