@featurevisor/core 0.53.4 → 0.54.0

package/src/datasource/datasource.ts

@@ -1,8 +1,3 @@
-import * as path from "path";
-import * as fs from "fs";
-
-import * as mkdirp from "mkdirp";
-
 import {
   ParsedFeature,
   Segment,
@@ -12,137 +7,35 @@ import {
   Test,
   EnvironmentKey,
   ExistingState,
+  SegmentKey,
+  AttributeKey,
 } from "@featurevisor/types";
 
-import { ProjectConfig } from "../config";
-import { parsers } from "./parsers";
-
-export type EntityType = "feature" | "group" | "segment" | "attribute" | "test";
+import { ProjectConfig, CustomParser } from "../config";
 
-export function getExistingStateFilePath(
-  projectConfig: ProjectConfig,
-  environment: EnvironmentKey,
-): string {
-  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
-}
+import { Adapter } from "./adapter";
 
 export class Datasource {
-  private extension;
-  private parse;
+  private adapter: Adapter;
 
   constructor(private config: ProjectConfig) {
-    if (typeof config.parser === "string") {
-      // built-in parsers
-      if (typeof parsers[config.parser] !== "function") {
-        throw new Error(`Invalid parser: ${config.parser}`);
-      }
-
-      this.extension = config.parser;
-      this.parse = parsers[config.parser];
-    } else if (typeof config.parser === "object") {
-      // custom parser
-      if (typeof config.parser.extension !== "string") {
-        throw new Error(`Invalid parser extension: ${config.parser.extension}`);
-      }
-
-      if (typeof config.parser.parse !== "function") {
-        throw new Error(`Invalid parser parse function: ${config.parser.parse}`);
-      }
-
-      this.extension = config.parser.extension;
-      this.parse = config.parser.parse;
-    } else {
-      throw new Error(`Invalid parser: ${config.parser}`);
-    }
+    this.adapter = new config.adapter(config);
   }
 
+  // @TODO: only site generator needs it, find a way to get it out of here later
   getExtension() {
-    return this.extension;
-  }
-
-  /**
-   * Common methods for entities
-   */
-  async listEntities(entityType: EntityType): Promise<string[]> {
-    const directoryPath = this.getEntityDirectoryPath(entityType);
-
-    if (!fs.existsSync(directoryPath)) {
-      return [];
-    }
-
-    return fs
-      .readdirSync(directoryPath)
-      .filter((fileName) => fileName.endsWith(`.${this.extension}`))
-      .map((fileName) => fileName.replace(`.${this.extension}`, ""));
-  }
-
-  getEntityDirectoryPath(entityType: EntityType): string {
-    if (entityType === "feature") {
-      return this.config.featuresDirectoryPath;
-    } else if (entityType === "group") {
-      return this.config.groupsDirectoryPath;
-    } else if (entityType === "segment") {
-      return this.config.segmentsDirectoryPath;
-    } else if (entityType === "test") {
-      return this.config.testsDirectoryPath;
-    }
-
-    return this.config.attributesDirectoryPath;
-  }
-
-  getEntityPath(entityType: EntityType, entityKey: string): string {
-    const basePath = this.getEntityDirectoryPath(entityType);
-
-    return path.join(basePath, `${entityKey}.${this.extension}`);
-  }
-
-  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
-    const entityPath = this.getEntityPath(entityType, entityKey);
-
-    return fs.existsSync(entityPath);
-  }
-
-  async readEntity(entityType: EntityType, entityKey: string): Promise<string> {
-    const filePath = this.getEntityPath(entityType, entityKey);
-
-    return fs.readFileSync(filePath, "utf8");
-  }
-
-  async parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
-    const entityContent = await this.readEntity(entityType, entityKey);
-
-    return this.parse(entityContent) as T;
+    return (this.config.parser as CustomParser).extension;
   }
 
   /**
    * State
    */
   async readState(environment: EnvironmentKey): Promise<ExistingState> {
-    const filePath = getExistingStateFilePath(this.config, environment);
-
-    if (!fs.existsSync(filePath)) {
-      return {
-        features: {},
-      };
-    }
-
-    return require(filePath);
+    return this.adapter.readState(environment);
   }
 
   async writeState(environment: EnvironmentKey, existingState: ExistingState) {
-    const filePath = getExistingStateFilePath(this.config, environment);
-
-    if (!fs.existsSync(this.config.stateDirectoryPath)) {
-      mkdirp.sync(this.config.stateDirectoryPath);
-    }
-    fs.writeFileSync(
-      filePath,
-      this.config.prettyState
-        ? JSON.stringify(existingState, null, 2)
-        : JSON.stringify(existingState),
-    );
-
-    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+    return this.adapter.writeState(environment, existingState);
   }
 
   /**
@@ -151,11 +44,15 @@ export class Datasource {
 
   // features
   async listFeatures() {
-    return await this.listEntities("feature");
+    return await this.adapter.listEntities("feature");
+  }
+
+  featureExists(featureKey: FeatureKey) {
+    return this.adapter.entityExists("feature", featureKey);
   }
 
-  readFeature(featureKey: string) {
-    return this.parseEntity<ParsedFeature>("feature", featureKey);
+  readFeature(featureKey: FeatureKey) {
+    return this.adapter.parseEntity<ParsedFeature>("feature", featureKey);
   }
 
   async getRequiredFeaturesChain(
@@ -164,7 +61,7 @@ export class Datasource {
   ): Promise<Set<FeatureKey>> {
     chain.add(featureKey);
 
-    if (!this.entityExists("feature", featureKey)) {
+    if (!this.adapter.entityExists("feature", featureKey)) {
       throw new Error(`Feature not found: ${featureKey}`);
     }
 
@@ -189,37 +86,53 @@ export class Datasource {
 
   // segments
   listSegments() {
-    return this.listEntities("segment");
+    return this.adapter.listEntities("segment");
+  }
+
+  segmentExists(segmentKey: SegmentKey) {
+    return this.adapter.entityExists("segment", segmentKey);
   }
 
-  readSegment(segmentKey: string) {
-    return this.parseEntity<Segment>("segment", segmentKey);
+  readSegment(segmentKey: SegmentKey) {
+    return this.adapter.parseEntity<Segment>("segment", segmentKey);
   }
 
   // attributes
   listAttributes() {
-    return this.listEntities("attribute");
+    return this.adapter.listEntities("attribute");
   }
 
-  readAttribute(attributeKey: string) {
-    return this.parseEntity<Attribute>("attribute", attributeKey);
+  attributeExists(attributeKey: AttributeKey) {
+    return this.adapter.entityExists("attribute", attributeKey);
+  }
+
+  readAttribute(attributeKey: AttributeKey) {
+    return this.adapter.parseEntity<Attribute>("attribute", attributeKey);
   }
 
   // groups
   async listGroups() {
-    return this.listEntities("group");
+    return this.adapter.listEntities("group");
+  }
+
+  groupExists(groupKey: string) {
+    return this.adapter.entityExists("group", groupKey);
   }
 
   readGroup(groupKey: string) {
-    return this.parseEntity<Group>("group", groupKey);
+    return this.adapter.parseEntity<Group>("group", groupKey);
   }
 
   // tests
   listTests() {
-    return this.listEntities("test");
+    return this.adapter.listEntities("test");
   }
 
   readTest(testKey: string) {
-    return this.parseEntity<Test>("test", testKey);
+    return this.adapter.parseEntity<Test>("test", testKey);
+  }
+
+  getTestSpecName(testKey: string) {
+    return `${testKey}.${this.getExtension()}`;
   }
 }

package/src/datasource/filesystemAdapter.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import * as mkdirp from "mkdirp";
+
+import { ExistingState, EnvironmentKey } from "@featurevisor/types";
+
+import { Adapter, EntityType } from "./adapter";
+import { ProjectConfig, CustomParser } from "../config";
+
+export function getExistingStateFilePath(
+  projectConfig: ProjectConfig,
+  environment: EnvironmentKey,
+): string {
+  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
+}
+
+export class FilesystemAdapter extends Adapter {
+  private parser: CustomParser;
+
+  constructor(private config: ProjectConfig) {
+    super();
+
+    this.parser = config.parser as CustomParser;
+  }
+
+  getEntityDirectoryPath(entityType: EntityType): string {
+    if (entityType === "feature") {
+      return this.config.featuresDirectoryPath;
+    } else if (entityType === "group") {
+      return this.config.groupsDirectoryPath;
+    } else if (entityType === "segment") {
+      return this.config.segmentsDirectoryPath;
+    } else if (entityType === "test") {
+      return this.config.testsDirectoryPath;
+    }
+
+    return this.config.attributesDirectoryPath;
+  }
+
+  getEntityPath(entityType: EntityType, entityKey: string): string {
+    const basePath = this.getEntityDirectoryPath(entityType);
+
+    return path.join(basePath, `${entityKey}.${this.parser.extension}`);
+  }
+
+  async listEntities(entityType: EntityType): Promise<string[]> {
+    const directoryPath = this.getEntityDirectoryPath(entityType);
+
+    if (!fs.existsSync(directoryPath)) {
+      return [];
+    }
+
+    return fs
+      .readdirSync(directoryPath)
+      .filter((fileName) => fileName.endsWith(`.${this.parser.extension}`))
+      .map((fileName) => fileName.replace(`.${this.parser.extension}`, ""));
+  }
+
+  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
+    const entityPath = this.getEntityPath(entityType, entityKey);
+
+    return fs.existsSync(entityPath);
+  }
+
+  async readEntity(entityType: EntityType, entityKey: string): Promise<string> {
+    const filePath = this.getEntityPath(entityType, entityKey);
+
+    return fs.readFileSync(filePath, "utf8");
+  }
+
+  async parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
+    const entityContent = await this.readEntity(entityType, entityKey);
+
+    return this.parser.parse<T>(entityContent);
+  }
+
+  /**
+   * State
+   */
+  async readState(environment: EnvironmentKey): Promise<ExistingState> {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        features: {},
+      };
+    }
+
+    return require(filePath);
+  }
+
+  async writeState(environment: EnvironmentKey, existingState: ExistingState) {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    if (!fs.existsSync(this.config.stateDirectoryPath)) {
+      mkdirp.sync(this.config.stateDirectoryPath);
+    }
+    fs.writeFileSync(
+      filePath,
+      this.config.prettyState
+        ? JSON.stringify(existingState, null, 2)
+        : JSON.stringify(existingState),
+    );
+
+    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+  }
+}

package/src/datasource/index.ts

@@ -1,2 +1,3 @@
 export * from "./datasource";
-export * from "./parsers";
+export * from "./adapter";
+export * from "./filesystemAdapter";

package/src/dependencies.ts

@@ -0,0 +1,13 @@
+import { ProjectConfig } from "./config";
+import { Datasource } from "./datasource";
+
+export interface Options {
+  [key: string]: any;
+}
+
+export interface Dependencies {
+  rootDirectoryPath: string;
+  projectConfig: ProjectConfig;
+  datasource: Datasource;
+  options: Options;
+}

package/src/find-duplicate-segments/index.ts

@@ -1,13 +1,8 @@
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
-
 import { findDuplicateSegments } from "./findDuplicateSegments";
+import { Dependencies } from "../dependencies";
 
-export async function findDuplicateSegmentsInProject(
-  rootDirectoryPath,
-  projectConfig: ProjectConfig,
-) {
-  const datasource = new Datasource(projectConfig);
+export async function findDuplicateSegmentsInProject(deps: Dependencies) {
+  const { datasource } = deps;
 
   const duplicates = await findDuplicateSegments(datasource);
 

package/src/generate-code/index.ts

@@ -3,9 +3,8 @@ import * as path from "path";
 
 import * as mkdirp from "mkdirp";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
 import { generateTypeScriptCodeForProject } from "./typescript";
+import { Dependencies } from "../dependencies";
 
 export const ALLOWED_LANGUAGES_FOR_CODE_GENERATION = ["typescript"];
 
@@ -15,10 +14,11 @@ export interface GenerateCodeCLIOptions {
 }
 
 export async function generateCodeForProject(
-  rootDirectoryPath,
-  projectConfig: ProjectConfig,
+  deps: Dependencies,
   cliOptions: GenerateCodeCLIOptions,
 ) {
+  const { rootDirectoryPath } = deps;
+
   if (!cliOptions.language) {
     throw new Error("Option `--language` is required");
   }
@@ -27,8 +27,6 @@ export async function generateCodeForProject(
     throw new Error("Option `--out-dir` is required");
   }
 
-  const datasource = new Datasource(projectConfig);
-
   const absolutePath = path.resolve(rootDirectoryPath, cliOptions.outDir);
 
   if (!fs.existsSync(absolutePath)) {
@@ -47,12 +45,7 @@ export async function generateCodeForProject(
   }
 
   if (cliOptions.language === "typescript") {
-    return await generateTypeScriptCodeForProject(
-      rootDirectoryPath,
-      projectConfig,
-      datasource,
-      absolutePath,
-    );
+    return await generateTypeScriptCodeForProject(deps, absolutePath);
   }
 
   throw new Error(`Language ${cliOptions.language} is not supported`);

package/src/generate-code/typescript.ts

@@ -1,9 +1,8 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
 import { Attribute } from "@featurevisor/types";
+import { Dependencies } from "../dependencies";
 
 function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
   switch (featurevisorType) {
@@ -87,12 +86,9 @@ export function getInstance(): FeaturevisorInstance {
 }
 `.trimStart();
 
-export async function generateTypeScriptCodeForProject(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-  datasource: Datasource,
-  outputPath: string,
-) {
+export async function generateTypeScriptCodeForProject(deps: Dependencies, outputPath: string) {
+  const { rootDirectoryPath, datasource } = deps;
+
   console.log("\nGenerating TypeScript code...\n");
 
   // instance

package/src/index.ts

@@ -7,3 +7,5 @@ export * from "./site";
 export * from "./generate-code";
 export * from "./restore";
 export * from "./find-duplicate-segments";
+export * from "./dependencies";
+export * from "./datasource";

package/src/linter/checkCircularDependency.ts

@@ -25,7 +25,7 @@ export async function checkForCircularDependencyInRequired(
       throw new Error(`circular dependency found: ${chain.join(" -> ")}`);
     }
 
-    const requiredFeatureExists = await datasource.entityExists("feature", requiredKey);
+    const requiredFeatureExists = await datasource.featureExists(featureKey);
 
     if (!requiredFeatureExists) {
       throw new Error(`required feature "${requiredKey}" not found`);

package/src/linter/lintProject.ts

@@ -1,9 +1,6 @@
 // for use in node only
 import * as Joi from "joi";
 
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
-
 import { getAttributeJoiSchema } from "./attributeSchema";
 import { getConditionsJoiSchema } from "./conditionSchema";
 import { getSegmentJoiSchema } from "./segmentSchema";
@@ -13,10 +10,12 @@ import { getTestsJoiSchema } from "./testSchema";
 
 import { checkForCircularDependencyInRequired } from "./checkCircularDependency";
 import { printJoiError } from "./printJoiError";
+import { Dependencies } from "../dependencies";
+
+export async function lintProject(deps: Dependencies): Promise<boolean> {
+  const { projectConfig, datasource } = deps;
 
-export async function lintProject(projectConfig: ProjectConfig): Promise<boolean> {
   let hasError = false;
-  const datasource = new Datasource(projectConfig);
 
   const availableAttributeKeys: string[] = [];
   const availableSegmentKeys: string[] = [];

package/src/{restore.ts → restore/index.ts}

@@ -1,9 +1,11 @@
 import * as path from "path";
 import { execSync } from "child_process";
 
-import { ProjectConfig } from "./config";
+import { Dependencies } from "../dependencies";
+
+export async function restoreProject(deps: Dependencies) {
+  const { rootDirectoryPath, projectConfig } = deps;
 
-export async function restoreProject(rootDirectoryPath, projectConfig: ProjectConfig) {
   const relativeStateDirPath = path.relative(rootDirectoryPath, projectConfig.stateDirectoryPath);
   const cmd = `git checkout -- ${relativeStateDirPath}${path.sep}`;
 

package/src/site/exportSite.ts

@@ -3,13 +3,14 @@ import * as path from "path";
 
 import * as mkdirp from "mkdirp";
 
-import { ProjectConfig } from "../config";
-
 import { generateHistory } from "./generateHistory";
 import { getRepoDetails } from "./getRepoDetails";
 import { generateSiteSearchIndex } from "./generateSiteSearchIndex";
+import { Dependencies } from "../dependencies";
+
+export async function exportSite(deps: Dependencies) {
+  const { rootDirectoryPath, projectConfig } = deps;
 
-export async function exportSite(rootDirectoryPath: string, projectConfig: ProjectConfig) {
   const hasError = false;
 
   mkdirp.sync(projectConfig.siteExportDirectoryPath);
@@ -30,12 +31,7 @@ export async function exportSite(rootDirectoryPath: string, projectConfig: Proje
 
   // site search index
   const repoDetails = getRepoDetails();
-  const searchIndex = await generateSiteSearchIndex(
-    rootDirectoryPath,
-    projectConfig,
-    fullHistory,
-    repoDetails,
-  );
+  const searchIndex = await generateSiteSearchIndex(deps, fullHistory, repoDetails);
   const searchIndexFilePath = path.join(projectConfig.siteExportDirectoryPath, "search-index.json");
   fs.writeFileSync(searchIndexFilePath, JSON.stringify(searchIndex));
   console.log(`Site search index written at: ${searchIndexFilePath}`);

package/src/site/generateSiteSearchIndex.ts

@@ -7,20 +7,20 @@ import {
   Condition,
 } from "@featurevisor/types";
 
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
 import { extractAttributeKeysFromConditions, extractSegmentKeysFromGroupSegments } from "../utils";
 
 import { getRelativePaths } from "./getRelativePaths";
 import { getLastModifiedFromHistory } from "./getLastModifiedFromHistory";
 import { RepoDetails } from "./getRepoDetails";
+import { Dependencies } from "../dependencies";
 
 export async function generateSiteSearchIndex(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
+  deps: Dependencies,
   fullHistory: HistoryEntry[],
   repoDetails: RepoDetails | undefined,
 ): Promise<SearchIndex> {
+  const { rootDirectoryPath, projectConfig, datasource } = deps;
+
   const result: SearchIndex = {
     links: undefined,
     entities: {
@@ -29,7 +29,6 @@ export async function generateSiteSearchIndex(
       features: [],
     },
   };
-  const datasource = new Datasource(projectConfig);
 
   /**
    * Links

package/src/site/serveSite.ts

@@ -2,13 +2,11 @@ import * as fs from "fs";
 import * as path from "path";
 import * as http from "http";
 
-import { ProjectConfig } from "../config";
+import { Dependencies } from "../dependencies";
+
+export function serveSite(deps: Dependencies) {
+  const { projectConfig, options } = deps;
 
-export function serveSite(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-  options: any = {},
-) {
   const port = options.p || 3000;
 
   http

package/src/tester/testProject.ts

@@ -2,19 +2,15 @@ import * as fs from "fs";
 
 import { TestSegment, TestFeature } from "@featurevisor/types";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
-
 import { testSegment } from "./testSegment";
 import { testFeature } from "./testFeature";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
+import { Dependencies } from "../dependencies";
+
+export async function testProject(deps: Dependencies): Promise<boolean> {
+  const { rootDirectoryPath, projectConfig, datasource } = deps;
 
-export async function testProject(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-): Promise<boolean> {
   let hasError = false;
-  const datasource = new Datasource(projectConfig);
 
   if (!fs.existsSync(projectConfig.testsDirectoryPath)) {
     console.error(`Tests directory does not exist: ${projectConfig.testsDirectoryPath}`);
@@ -33,7 +29,7 @@ export async function testProject(
   }
 
   for (const testFile of testFiles) {
-    const testFilePath = datasource.getEntityPath("test", testFile);
+    const testFilePath = datasource.getTestSpecName(testFile);
 
     console.log("");
     console.log(CLI_FORMAT_BOLD, `Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);

package/src/tester/testSegment.ts

@@ -12,7 +12,7 @@ export async function testSegment(datasource: Datasource, test: TestSegment): Pr
 
   console.log(CLI_FORMAT_BOLD, `  Segment "${segmentKey}":`);
 
-  const segmentExists = await datasource.entityExists("segment", segmentKey);
+  const segmentExists = await datasource.segmentExists(segmentKey);
 
   if (!segmentExists) {
     console.error(CLI_FORMAT_RED, `  Segment does not exist: ${segmentKey}`);

package/lib/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAAA,2BAA6B;AAMhB,QAAA,uBAAuB,GAAG,UAAU,CAAC;AACrC,QAAA,uBAAuB,GAAG,UAAU,CAAC;AACrC,QAAA,yBAAyB,GAAG,YAAY,CAAC;AACzC,QAAA,qBAAqB,GAAG,QAAQ,CAAC;AACjC,QAAA,oBAAoB,GAAG,OAAO,CAAC;AAC/B,QAAA,oBAAoB,GAAG,eAAe,CAAC;AACvC,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAC/B,QAAA,0BAA0B,GAAG,KAAK,CAAC;AAEnC,QAAA,kBAAkB,GAAG,wBAAwB,CAAC;AAC9C,QAAA,oBAAoB,GAAG,WAAW,CAAC;AAEnC,QAAA,oBAAoB,GAAG,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AACjD,QAAA,YAAY,GAAG,CAAC,KAAK,CAAC,CAAC;AACvB,QAAA,2BAA2B,GAAG,QAAQ,CAAC;AAEvC,QAAA,oBAAoB,GAAG,KAAK,CAAC;AAC7B,QAAA,uBAAuB,GAAG,KAAK,CAAC;AAEhC,QAAA,cAAc,GAAW,KAAK,CAAC;AAE/B,QAAA,cAAc,GAAG,GAAG,CAAC;AAmBlC,6FAA6F;AAC7F,SAAgB,gBAAgB,CAAC,iBAAyB;IACxD,IAAM,UAAU,GAAkB;QAChC,qBAAqB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,+BAAuB,CAAC;QAC5E,qBAAqB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,+BAAuB,CAAC;QAC5E,uBAAuB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,iCAAyB,CAAC;QAChF,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,6BAAqB,CAAC;QACxE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,4BAAoB,CAAC;QAEtE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,4BAAoB,CAAC;QACtE,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,6BAAqB,CAAC;QAExE,YAAY,EAAE,4BAAoB;QAClC,IAAI,EAAE,oBAAY;QAClB,eAAe,EAAE,QAAQ;QAEzB,MAAM,EAAE,sBAAc;QAEtB,WAAW,EAAE,4BAAoB;QACjC,cAAc,EAAE,+BAAuB;QAEvC,uBAAuB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,kCAA0B,CAAC;KAClF,CAAC;IAEF,IAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,0BAAkB,CAAC,CAAC;IAC1E,IAAM,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE/C,IAAM,WAAW,GAAG,EAAE,CAAC;IAEvB,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,UAAC,GAAG;QAClC,WAAW,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC;QAExD,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,4BAAoB,CAAC,KAAK,CAAC,CAAC,EAAE;YACjF,WAAW,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,4BAAoB,EAAE,iBAAiB,CAAC,CAAC;SACtF;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,WAA4B,CAAC;AACtC,CAAC;AArCD,4CAqCC"}

package/lib/datasource/parsers.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsers = void 0;
-var YAML = require("js-yaml");
-/**
- * If we want to add more built-in parsers,
- * add them to this object with new file extension as the key,
- * and a function that takes file content as string and returns parsed object as the value.
- */
-exports.parsers = {
-    // extension => function
-    yml: function (content) {
-        return YAML.load(content);
-    },
-    json: function (content) {
-        return JSON.parse(content);
-    },
-};
-//# sourceMappingURL=parsers.js.map