@teambit/graphql 0.0.555 → 0.0.556

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/graphql",
-  "version": "0.0.555",
+  "version": "0.0.556",
   "homepage": "https://bit.dev/teambit/harmony/graphql",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.harmony",
     "name": "graphql",
-    "version": "0.0.555"
+    "version": "0.0.556"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -32,12 +32,12 @@
     "bufferutil": "4.0.3",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/cli": "0.0.386",
-    "@teambit/logger": "0.0.471",
-    "@teambit/toolbox.network.get-port": "0.0.90",
-    "@teambit/preview": "0.0.555",
-    "@teambit/ui": "0.0.555",
-    "@teambit/ui-foundation.ui.is-browser": "0.0.463"
+    "@teambit/cli": "0.0.387",
+    "@teambit/logger": "0.0.472",
+    "@teambit/toolbox.network.get-port": "0.0.91",
+    "@teambit/preview": "0.0.556",
+    "@teambit/ui": "0.0.556",
+    "@teambit/ui-foundation.ui.is-browser": "0.0.464"
   },
   "devDependencies": {
     "@types/cors": "2.8.10",
@@ -54,7 +54,7 @@
   "peerDependencies": {
     "@apollo/client": "^3.0.0",
     "graphql": "14.7.0",
-    "@teambit/legacy": "1.0.172",
+    "@teambit/legacy": "1.0.173",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -84,12 +84,18 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.172",
+        "@teambit/legacy": "1.0.173",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "README.md",
+    "README.mdx"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/create-link.ts

@@ -1,20 +0,0 @@
-import { HttpLink, split } from '@apollo/client';
-import { getMainDefinition } from '@apollo/client/utilities';
-import type { WebSocketLink } from '@apollo/client/link/ws';
-
-/**
- * create a link which splits routes data depending on type of operation.
- * @param httpLink http link for apollo graphql
- * @param wsLink web socket link for apollo graphql
- */
-export function createSplitLink(httpLink: HttpLink, wsLink: WebSocketLink) {
-  return split(
-    // split based on operation type
-    ({ query }) => {
-      const definition = getMainDefinition(query);
-      return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
-    },
-    wsLink,
-    httpLink
-  );
-}

package/create-remote-schemas/create-remote-schemas.ts

@@ -1,58 +0,0 @@
-import fetch from 'node-fetch';
-import { setContext } from 'apollo-link-context';
-import { HttpLink } from 'apollo-link-http';
-import { makeRemoteExecutableSchema, introspectSchema } from 'apollo-server';
-import { WebSocketLink } from 'apollo-link-ws';
-import { split } from 'apollo-link';
-import { getMainDefinition } from 'apollo-utilities';
-import { SubscriptionClient } from 'subscriptions-transport-ws';
-import ws from 'ws';
-import { GraphQLServer } from '../graphql-server';
-
-async function getRemoteSchema({ uri, subscriptionsUri }) {
-  // @ts-ignore
-  const http = new HttpLink({ uri, fetch });
-  const httpLink = setContext((request, previousContext) => {
-    return {
-      headers: previousContext?.graphqlContext?.headers,
-    };
-  }).concat(http);
-
-  if (!subscriptionsUri) {
-    return makeRemoteExecutableSchema({
-      schema: await introspectSchema(httpLink),
-      link: httpLink,
-    });
-  }
-
-  // Create WebSocket link with custom client
-  const client = new SubscriptionClient(subscriptionsUri, { reconnect: true }, ws);
-  const wsLink = new WebSocketLink(client);
-
-  // Using the ability to split links, we can send data to each link
-  // depending on what kind of operation is being sent
-  const link = split(
-    (operation) => {
-      const definition = getMainDefinition(operation.query);
-      return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
-    },
-    wsLink,
-    httpLink
-  );
-
-  return makeRemoteExecutableSchema({
-    schema: await introspectSchema(httpLink),
-    link,
-  });
-}
-
-export async function createRemoteSchemas(servers: GraphQLServer[]) {
-  const schemasP = servers.map(async (server) => {
-    return getRemoteSchema({
-      uri: server.uri,
-      subscriptionsUri: server.subscriptionsUri,
-    });
-  });
-
-  return Promise.all(schemasP);
-}

package/create-remote-schemas/index.ts

@@ -1 +0,0 @@
-export { createRemoteSchemas } from './create-remote-schemas';

package/graphql-error.ts

@@ -1,13 +0,0 @@
-export class GraphQlError {
-  constructor(
-    /**
-     * http status code of error
-     */
-    public readonly code: number,
-
-    /**
-     * error message of the error
-     */
-    public readonly message?: string
-  ) {}
-}

package/graphql-provider/graphql-provider.tsx

@@ -1,12 +0,0 @@
-import React, { ReactNode } from 'react';
-import { ApolloProvider } from '@apollo/client';
-import type { GraphQLClient } from '../graphql.ui.runtime';
-
-export type GraphQLProviderProps = {
-  client: GraphQLClient<any>;
-  children: ReactNode;
-};
-
-export function GraphQLProvider({ client, children }: GraphQLProviderProps) {
-  return <ApolloProvider client={client}>{children}</ApolloProvider>;
-}

package/graphql-provider/index.ts

@@ -1 +0,0 @@
-export { GraphQLProvider } from './graphql-provider';

package/graphql-server.ts

@@ -1,5 +0,0 @@
-export interface GraphQLServer {
-  uri: string;
-
-  subscriptionsUri?: string;
-}

package/graphql.aspect.ts

@@ -1,9 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const GraphqlAspect = Aspect.create({
-  id: 'teambit.harmony/graphql',
-  dependencies: [],
-  defaultConfig: {},
-});
-
-export default GraphqlAspect;

package/graphql.main.runtime.ts

@@ -1,282 +0,0 @@
-import { mergeSchemas } from 'graphql-tools';
-import { GraphQLModule } from '@graphql-modules/core';
-import { MainRuntime } from '@teambit/cli';
-import { Harmony, Slot, SlotRegistry } from '@teambit/harmony';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import express, { Express } from 'express';
-import { graphqlHTTP } from 'express-graphql';
-import { Port } from '@teambit/toolbox.network.get-port';
-import { execute, subscribe } from 'graphql';
-import { PubSub } from 'graphql-subscriptions';
-import { createServer, Server } from 'http';
-import httpProxy from 'http-proxy';
-import { SubscriptionServer } from 'subscriptions-transport-ws';
-import cors from 'cors';
-import { GraphQLServer } from './graphql-server';
-import { createRemoteSchemas } from './create-remote-schemas';
-import { GraphqlAspect } from './graphql.aspect';
-import { Schema } from './schema';
-
-export enum Verb {
-  WRITE = 'write',
-  READ = 'read',
-}
-
-export type GraphQLConfig = {
-  port: number;
-  subscriptionsPortRange: number[];
-  subscriptionsPath: string;
-};
-
-export type GraphQLServerSlot = SlotRegistry<GraphQLServer>;
-
-export type SchemaSlot = SlotRegistry<Schema>;
-
-export type GraphQLServerOptions = {
-  schemaSlot?: SchemaSlot;
-  app?: Express;
-  graphiql?: boolean;
-  remoteSchemas?: GraphQLServer[];
-  subscriptionsPortRange?: number[];
-  onWsConnect?: Function;
-};
-
-export class GraphqlMain {
-  constructor(
-    /**
-     * extension config
-     */
-    readonly config: GraphQLConfig,
-
-    /**
-     * slot for registering graphql modules
-     */
-    private moduleSlot: SchemaSlot,
-
-    /**
-     * harmony context.
-     */
-    private context: Harmony,
-
-    /**
-     * graphql pubsub. allows to emit events to clients.
-     */
-    readonly pubsub: PubSub,
-
-    /**
-     * logger extension.
-     */
-    readonly logger: Logger,
-
-    private graphQLServerSlot: GraphQLServerSlot
-  ) {}
-
-  private modules = new Map<string, GraphQLModule>();
-
-  async createServer(options: GraphQLServerOptions) {
-    const { graphiql = true } = options;
-    const localSchema = this.createRootModule(options.schemaSlot);
-    const remoteSchemas = await createRemoteSchemas(options.remoteSchemas || this.graphQLServerSlot.values());
-    const schemas = [localSchema.schema].concat(remoteSchemas).filter((x) => x);
-    const schema = mergeSchemas({
-      schemas,
-    });
-
-    // TODO: @guy please consider to refactor to express extension.
-    const app = options.app || express();
-    app.use(
-      // @ts-ignore todo: it's not clear what's the issue.
-      cors({
-        origin(origin, callback) {
-          callback(null, true);
-        },
-        credentials: true,
-      })
-    );
-
-    app.use(
-      '/graphql',
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      graphqlHTTP((request, res, params) => ({
-        customFormatErrorFn: (err) => {
-          this.logger.error('graphql got an error during running the following query:', params);
-          this.logger.error('graphql error ', err);
-          return Object.assign(err, {
-            // @ts-ignore
-            ERR_CODE: err?.originalError?.errors?.[0].ERR_CODE || err.originalError?.constructor?.name,
-            // @ts-ignore
-            HTTP_CODE: err?.originalError?.errors?.[0].HTTP_CODE || err.originalError?.code,
-          });
-        },
-        schema,
-        rootValue: request,
-        graphiql,
-      }))
-    );
-
-    const server = createServer(app);
-    const subscriptionsPort = options.subscriptionsPortRange || this.config.subscriptionsPortRange;
-    const subscriptionServerPort = await this.getPort(subscriptionsPort);
-    const { port } = await this.createSubscription(options, subscriptionServerPort);
-    this.proxySubscription(server, port);
-
-    return server;
-  }
-
-  /**
-   * register a new graphql server.
-   */
-  registerServer(server: GraphQLServer) {
-    this.graphQLServerSlot.register(server);
-    return this;
-  }
-
-  /**
-   * start a graphql server.
-   */
-  async listen(port?: number, server?: Server, app?: Express) {
-    const serverPort = port || this.config.port;
-    const subServer = server || (await this.createServer({ app }));
-
-    subServer.listen(serverPort, () => {
-      this.logger.info(`API Server over HTTP is now running on http://localhost:${serverPort}`);
-      this.logger.info(
-        `API Server over web socket with subscriptions is now running on ws://localhost:${serverPort}/${this.config.subscriptionsPath}`
-      );
-    });
-  }
-
-  /**
-   * register a new graphql module.
-   */
-  register(schema: Schema) {
-    // const module = new GraphQLModule(schema);
-    this.moduleSlot.register(schema);
-    return this;
-  }
-
-  private async getPort(range: number[]) {
-    const [from, to] = range;
-    return Port.getPort(from, to);
-  }
-
-  /** create Subscription server with different port */
-
-  private async createSubscription(options: GraphQLServerOptions, port: number) {
-    // Create WebSocket listener server
-    const websocketServer = createServer((request, response) => {
-      response.writeHead(404);
-      response.end();
-    });
-
-    // Bind it to port and start listening
-    websocketServer.listen(port, () =>
-      this.logger.debug(`Websocket Server is now running on http://localhost:${port}`)
-    );
-
-    const localSchema = this.createRootModule(options.schemaSlot);
-    const remoteSchemas = await createRemoteSchemas(options.remoteSchemas || this.graphQLServerSlot.values());
-    const schemas = [localSchema.schema].concat(remoteSchemas).filter((x) => x);
-    const schema = mergeSchemas({
-      schemas,
-    });
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const subServer = new SubscriptionServer(
-      {
-        execute,
-        subscribe,
-        schema,
-        onConnect: options.onWsConnect,
-      },
-      {
-        server: websocketServer,
-        path: this.config.subscriptionsPath,
-      }
-    );
-    return { subServer, port };
-  }
-  /** proxy ws Subscription server to avoid conflict with different websocket connections */
-
-  private proxySubscription(server: Server, port: number) {
-    const proxServer = httpProxy.createProxyServer();
-    const subscriptionsPath = this.config.subscriptionsPath;
-    const logger = this.logger;
-    server.on('upgrade', function (req, socket, head) {
-      if (req.url === subscriptionsPath) {
-        logger.debug(`proxy from ${req.url} to ${port}`);
-        proxServer.ws(req, socket, head, { target: { host: 'localhost', port } });
-      }
-    });
-  }
-
-  private createRootModule(schemaSlot?: SchemaSlot) {
-    const modules = this.buildModules(schemaSlot);
-
-    return new GraphQLModule({
-      imports: modules,
-    });
-  }
-
-  private buildModules(schemaSlot?: SchemaSlot) {
-    const schemaSlots = schemaSlot ? schemaSlot.toArray() : this.moduleSlot.toArray();
-    return schemaSlots.map(([extensionId, schema]) => {
-      const moduleDeps = this.getModuleDependencies(extensionId);
-
-      const module = new GraphQLModule({
-        typeDefs: schema.typeDefs,
-        resolvers: schema.resolvers,
-        imports: moduleDeps,
-        context: (session) => {
-          return {
-            ...session,
-            verb: session?.headers?.['x-verb'] || Verb.READ,
-          };
-        },
-      });
-
-      this.modules.set(extensionId, module);
-
-      return module;
-    });
-  }
-
-  private getModuleDependencies(extensionId: string): GraphQLModule[] {
-    const extension = this.context.extensions.get(extensionId);
-    if (!extension) throw new Error(`aspect ${extensionId} was not found`);
-    const deps = this.context.getDependencies(extension);
-    const ids = deps.map((dep) => dep.id);
-
-    // @ts-ignore check :TODO why types are breaking here.
-    return Array.from(this.modules.entries())
-      .map(([depId, module]) => {
-        const dep = ids.includes(depId);
-        if (!dep) return undefined;
-        return module;
-      })
-      .filter((module) => !!module);
-  }
-
-  static slots = [Slot.withType<Schema>(), Slot.withType<GraphQLServer>()];
-
-  static defaultConfig = {
-    port: 4000,
-    subscriptionsPortRange: [2000, 2100],
-    subscriptionsPath: '/subscriptions',
-  };
-
-  static runtime = MainRuntime;
-  static dependencies = [LoggerAspect];
-
-  static async provider(
-    [loggerFactory]: [LoggerMain],
-    config: GraphQLConfig,
-    [moduleSlot, graphQLServerSlot]: [SchemaSlot, GraphQLServerSlot],
-    context: Harmony
-  ) {
-    const logger = loggerFactory.createLogger(GraphqlAspect.id);
-    return new GraphqlMain(config, moduleSlot, context, new PubSub(), logger, graphQLServerSlot);
-  }
-}
-
-GraphqlAspect.addRuntime(GraphqlMain);

package/graphql.preview.runtime.tsx

@@ -1,7 +0,0 @@
-import { PreviewRuntime } from '@teambit/preview';
-
-import { GraphqlAspect } from './graphql.aspect';
-import { GraphqlUI } from './graphql.ui.runtime';
-
-GraphqlUI.runtime = PreviewRuntime;
-GraphqlAspect.addRuntime(GraphqlUI);

package/graphql.ui.runtime.tsx

@@ -1,103 +0,0 @@
-import React, { ReactNode } from 'react';
-import { UIRuntime } from '@teambit/ui';
-
-import { InMemoryCache, ApolloClient, ApolloLink, HttpLink, createHttpLink } from '@apollo/client';
-import type { NormalizedCacheObject } from '@apollo/client';
-import { WebSocketLink } from '@apollo/client/link/ws';
-import { onError } from '@apollo/client/link/error';
-
-import crossFetch from 'cross-fetch';
-
-import { createSplitLink } from './create-link';
-import { GraphQLProvider } from './graphql-provider';
-import { GraphqlAspect } from './graphql.aspect';
-import { GraphqlRenderLifecycle } from './render-lifecycle';
-import { logError } from './logging';
-
-/**
- * Type of gql client.
- * Used to abstract Apollo client, so consumers could import the type from graphql.ui, and not have to depend on @apollo/client directly
- * */
-export type GraphQLClient<T> = ApolloClient<T>;
-
-type ClientOptions = {
-  /** Preset in-memory cache with state (e.g. continue state from SSR) */
-  state?: NormalizedCacheObject;
-  /** endpoint for websocket connections */
-  subscriptionUri?: string;
-};
-
-export class GraphqlUI {
-  createClient(uri: string, { state, subscriptionUri }: ClientOptions = {}) {
-    const client = new ApolloClient({
-      link: this.createLink(uri, { subscriptionUri }),
-      cache: this.createCache({ state }),
-    });
-
-    return client;
-  }
-
-  createSsrClient({ serverUrl, headers }: { serverUrl: string; headers: any }) {
-    const link = ApolloLink.from([
-      onError(logError),
-      createHttpLink({
-        credentials: 'include',
-        uri: serverUrl,
-        headers,
-        fetch: crossFetch,
-      }),
-    ]);
-
-    const client = new ApolloClient({
-      ssrMode: true,
-      link,
-      cache: this.createCache(),
-    });
-
-    return client;
-  }
-
-  private createCache({ state }: { state?: NormalizedCacheObject } = {}) {
-    const cache = new InMemoryCache();
-
-    if (state) cache.restore(state);
-
-    return cache;
-  }
-
-  private createLink(uri: string, { subscriptionUri }: { subscriptionUri?: string } = {}) {
-    const httpLink = new HttpLink({ credentials: 'include', uri });
-    const subsLink = subscriptionUri
-      ? new WebSocketLink({
-          uri: subscriptionUri,
-          options: { reconnect: true },
-        })
-      : undefined;
-
-    const hybridLink = subsLink ? createSplitLink(httpLink, subsLink) : httpLink;
-    const errorLogger = onError(logError);
-
-    return ApolloLink.from([errorLogger, hybridLink]);
-  }
-
-  /**
-   * get the graphQL provider
-   */
-  getProvider = ({ client, children }: { client: GraphQLClient<any>; children: ReactNode }) => {
-    return <GraphQLProvider client={client}>{children}</GraphQLProvider>;
-  };
-
-  renderHooks = new GraphqlRenderLifecycle(this);
-
-  static runtime = UIRuntime;
-  static dependencies = [];
-  static slots = [];
-
-  static async provider() {
-    const graphqlUI = new GraphqlUI();
-
-    return graphqlUI;
-  }
-}
-
-GraphqlAspect.addRuntime(GraphqlUI);

package/index.ts

@@ -1,8 +0,0 @@
-export { GraphqlAspect, GraphqlAspect as default } from './graphql.aspect';
-
-export type { Schema } from './schema';
-export type { GraphqlMain, SchemaSlot } from './graphql.main.runtime';
-export type { GraphqlUI, GraphQLClient } from './graphql.ui.runtime';
-export type { GraphQLServer } from './graphql-server';
-export { GraphQLProvider } from './graphql-provider';
-export { GraphQlError } from './graphql-error';

package/logging.ts

@@ -1,26 +0,0 @@
-import { ErrorResponse } from '@apollo/client/link/error';
-
-export function logError({ graphQLErrors, networkError, operation }: ErrorResponse) {
-  if (graphQLErrors)
-    graphQLErrors.forEach(({ message, locations, path }) =>
-      // eslint-disable-next-line no-console
-      console.error(`[gql] error on "${operation.operationName}" - "${message}"`, locations, path)
-    );
-
-  // eslint-disable-next-line no-console
-  if (networkError) console.error('[gql] network error', `"${operation.operationName}"`, networkError);
-}
-
-// // // a fetch monkey patch with logs. useful to debug gql
-// function loggingCrossFetch(...p: Parameters<typeof fetch>) {
-//   const [url, init] = p;
-//   const headers = init?.headers;
-//   const body = init?.body;
-
-//   console.debug('[gql]', 'fetching', url, body, { headers });
-//   const promise = crossFetch(...p);
-//   promise
-//     .then((result) => console.debug('[gql]', 'finished', result))
-//     .catch((err) => console.debug('[gql]', 'error', err));
-//   return promise;
-// }

package/render-lifecycle.tsx

@@ -1,91 +0,0 @@
-import React, { ReactNode } from 'react';
-import { getDataFromTree } from '@apollo/client/react/ssr';
-import type { NormalizedCacheObject } from '@apollo/client';
-import pick from 'lodash.pick';
-
-import { isBrowser } from '@teambit/ui-foundation.ui.is-browser';
-import type { BrowserData, RenderLifecycle } from '@teambit/ui';
-
-import type { GraphqlUI, GraphQLClient } from './graphql.ui.runtime';
-import { GraphQLProvider } from './graphql-provider';
-
-type RenderContext = {
-  client: GraphQLClient<any>;
-};
-
-const ALLOWED_HEADERS = ['cookie'];
-
-export class GraphqlRenderLifecycle implements RenderLifecycle<RenderContext, { state?: NormalizedCacheObject }> {
-  constructor(private graphqlUI: GraphqlUI) {}
-
-  serverInit = ({ browser, server }: { browser?: BrowserData; server?: { port: number } } = {}) => {
-    if (!browser) return undefined;
-
-    const port = server?.port || 3000;
-    const serverUrl = `http://localhost:${port}/graphql`;
-
-    const client = this.graphqlUI.createSsrClient({
-      serverUrl,
-      headers: pick(browser.connection.headers, ALLOWED_HEADERS),
-    });
-
-    const ctx: RenderContext = { client };
-    return ctx;
-  };
-
-  /**
-   * Eagerly and recursively execute all gql queries in the app.
-   * Data will be available in gqlClient.extract()
-   */
-  onBeforeRender = async (ctx: RenderContext, app: ReactNode) => {
-    await getDataFromTree(app);
-  };
-
-  serialize = (ctx?: RenderContext) => {
-    const client = ctx?.client;
-    if (!client) return undefined;
-
-    return {
-      json: JSON.stringify(client.extract()),
-    };
-  };
-
-  deserialize = (raw?: string) => {
-    if (!raw) return { state: undefined };
-    let state: NormalizedCacheObject | undefined;
-    try {
-      state = JSON.parse(raw);
-    } catch (e) {
-      // eslint-disable-next-line no-console
-      console.error('[GraphQL] failed deserializing state from DOM', e);
-    }
-
-    return { state };
-  };
-
-  browserInit = ({ state }: { state?: NormalizedCacheObject } = {}) => {
-    const { location } = window;
-    const isInsecure = location.protocol === 'http:';
-    const wsUrl = `${isInsecure ? 'ws:' : 'wss:'}//${location.host}/subscriptions`;
-
-    const client = this.graphqlUI.createClient('/graphql', { state, subscriptionUri: wsUrl });
-
-    return { client };
-  };
-
-  private BrowserGqlProvider = ({ renderCtx, children }: { renderCtx?: RenderContext; children: ReactNode }) => {
-    if (!renderCtx?.client) throw new TypeError('GQL client is not initialized, make sure `.browserInit()` executes');
-
-    return <this.graphqlUI.getProvider client={renderCtx?.client}>{children}</this.graphqlUI.getProvider>;
-  };
-
-  reactContext = isBrowser ? this.BrowserGqlProvider : ServerGqlProvider;
-}
-
-function ServerGqlProvider({ renderCtx, children }: { renderCtx?: RenderContext; children: ReactNode }) {
-  if (!renderCtx?.client)
-    throw new TypeError('GQL client has not been initialized during SSR, make sure `.serverInit()` executes');
-
-  const { client } = renderCtx;
-  return <GraphQLProvider client={client}>{children}</GraphQLProvider>;
-}

package/schema.ts

@@ -1,9 +0,0 @@
-import type { DocumentNode } from 'graphql';
-
-/**
- * graphql schema for an extension.
- */
-export type Schema = {
-  typeDefs?: string | DocumentNode;
-  resolvers?: { [key: string]: any };
-};

package/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
-    ],
-    "target": "es2015",
-    "module": "commonjs",
-    "jsx": "react",
-    "declaration": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "outDir": "dist",
-    "composite": true,
-    "emitDeclarationOnly": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "rootDir": ".",
-    "preserveConstEnums": true,
-    "resolveJsonModule": true
-  },
-  "exclude": [
-    "dist"
-  ]
-}

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-declare module '*.png' {
-  const value: any;
-  export = value;
-}
-declare module '*.svg' {
-  import type { FunctionComponent, SVGProps } from 'react';
-
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
-  const src: string;
-  export default src;
-}
-
-// @TODO Gilad
-declare module '*.jpg' {
-  const value: any;
-  export = value;
-}
-declare module '*.jpeg' {
-  const value: any;
-  export = value;
-}
-declare module '*.gif' {
-  const value: any;
-  export = value;
-}
-declare module '*.bmp' {
-  const value: any;
-  export = value;
-}

package/types/style.d.ts

@@ -1,42 +0,0 @@
-declare module '*.module.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.module.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.mdx' {
-  const component: any;
-  export default component;
-}