@api-client/core 0.5.16 → 0.5.19

package/src/lib/parsers/UriTemplate.ts

@@ -134,11 +134,14 @@ interface IPart {
   variables: IVariable[];
 }
 
-export interface IUriTemplateOptions {
+export interface IUriTemplateParseOptions {
   /**
-   * Throws when a variable is not found to replaces a value in the template.
+   * Throws an error when template literals are invalid
    */
   strict?: boolean;
+}
+
+export interface IUriTemplateOptions extends IUriTemplateParseOptions {
   /**
    * When set it ignores replacing the value in the template when the variable is missing.
    */
@@ -253,13 +256,15 @@ export class UriTemplate {
   expand(map: Record<string, any>, opts: IUriTemplateOptions = {}): string {
     let result = '';
     if (!this.parts || !this.parts.length) {
-      this.parse();
+      this.parse(opts);
     }
-    const data = new Data(map);
-
+    const data = UriTemplate.getData(map);
     for (const part of this.parts!) {
-      const item = typeof part === 'string' ? part : UriTemplate.expand(part, data, opts);
-      result += item;
+      if (typeof part === 'string') {
+        result += UriTemplate.expandString(part);
+      } else {
+        result += UriTemplate.expand(part, data, opts);
+      }
     }
     return result;
   }
@@ -267,13 +272,13 @@ export class UriTemplate {
   /**
    * Parses the template into action tokens.
    */
-  parse(): void {
+  parse(opts: IUriTemplateParseOptions = {}): void {
     const { expression } = this;
     const parts: (string | IPart)[] = [];
     let pos = 0;
 
     function checkLiteral(literal: string): string {
-      if (literal.match(LITERAL_PATTERN)) {
+      if (opts.strict && literal.match(LITERAL_PATTERN)) {
         throw new Error(`Invalid Literal "${literal}"`);
       }
       return literal;
@@ -338,12 +343,31 @@ export class UriTemplate {
     this.parts = parts;
   }
 
+  /**
+   * Creates a Data object with the passed map.
+   * 
+   * @param map The map with values.
+   */
+  protected static getData(map: Record<string, any>): Data {
+    return new Data(map);
+  }
+
+  /**
+   * Can be used by a child class to manipulate string parts that are not template expressions
+   * 
+   * @param part The string part
+   * @returns The processed part.
+   */
+  protected static expandString(part: string): string {
+    return part;
+  }
+
   protected static expand(expression: IPart, data: Data, opts: IUriTemplateOptions = {}): string {
     const options = operators[expression.operator];
     const type = options.named ? 'Named' : 'Unnamed';
     const { variables } = expression;
     const buffer = [];
-
+    
     for (const variable of variables) {
       const d = data.get(variable.name);
       if (d.type === DataType.nil && opts && opts.strict) {
@@ -444,7 +468,6 @@ export class UriTemplate {
     let result = '';
     const { encode, empty_name_separator } = options;
     const _encode = !d[encode].length;
-
     d.val.forEach((item, index) => {
       let _value: string;
       if (length) {