@storybook/csf 0.0.2--canary.507502b.0 → 0.0.2--canary.7c6c115.0

package/dist/includeConditionalArg.d.ts

@@ -0,0 +1,3 @@
+import { Args, Globals, InputType, Conditional } from './story';
+export declare const testValue: (cond: Pick<Conditional, never>, value: any) => boolean;
+export declare const includeConditionalArg: (argType: InputType, args: Args, globals: Globals) => boolean;

package/dist/includeConditionalArg.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.includeConditionalArg = exports.testValue = void 0;
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var count = function count(vals) {
+  return vals.map(function (v) {
+    return typeof v !== 'undefined';
+  }).filter(Boolean).length;
+};
+
+var testValue = function testValue(cond, value) {
+  var _ref = cond,
+      exists = _ref.exists,
+      eq = _ref.eq,
+      neq = _ref.neq,
+      truthy = _ref.truthy;
+
+  if (count([exists, eq, neq, truthy]) > 1) {
+    throw new Error("Invalid conditional test ".concat(JSON.stringify({
+      exists: exists,
+      eq: eq,
+      neq: neq
+    })));
+  }
+
+  if (typeof eq !== 'undefined') {
+    return (0, _isEqual["default"])(value, eq);
+  }
+
+  if (typeof neq !== 'undefined') {
+    return !(0, _isEqual["default"])(value, neq);
+  }
+
+  if (typeof exists !== 'undefined') {
+    var valueExists = typeof value !== 'undefined';
+    return exists ? valueExists : !valueExists;
+  }
+
+  var shouldBeTruthy = typeof truthy === 'undefined' ? true : truthy;
+  return shouldBeTruthy ? !!value : !value;
+};
+/**
+ * Helper function to include/exclude an arg based on the value of other other args
+ * aka "conditional args"
+ */
+
+
+exports.testValue = testValue;
+
+var includeConditionalArg = function includeConditionalArg(argType, args, globals) {
+  if (!argType["if"]) return true;
+  var _ref2 = argType["if"],
+      arg = _ref2.arg,
+      global = _ref2.global;
+
+  if (count([arg, global]) !== 1) {
+    throw new Error("Invalid conditional value ".concat(JSON.stringify({
+      arg: arg,
+      global: global
+    })));
+  }
+
+  var value = arg ? args[arg] : globals[global];
+  return testValue(argType["if"], value);
+};
+
+exports.includeConditionalArg = includeConditionalArg;

package/dist/includeConditionalArg.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/includeConditionalArg.test.js

@@ -0,0 +1,318 @@
+"use strict";
+
+var _includeConditionalArg = require("./includeConditionalArg");
+
+/* eslint-disable @typescript-eslint/ban-ts-ignore */
+describe('testValue', function () {
+  describe('truthy', function () {
+    it.each([['implicit true', {}, true, true], ['implicit truthy', {}, 1, true], ['implicit falsey', {}, 0, false], ['truthy true', {
+      truthy: true
+    }, true, true], ['truthy truthy', {
+      truthy: true
+    }, 1, true], ['truthy falsey', {
+      truthy: true
+    }, 0, false], ['falsey true', {
+      truthy: false
+    }, true, false], ['falsey truthy', {
+      truthy: false
+    }, 1, false], ['falsey falsey', {
+      truthy: false
+    }, 0, true]])('%s', function (_name, cond, value, expected) {
+      // @ts-ignore
+      expect((0, _includeConditionalArg.testValue)(cond, value)).toBe(expected);
+    });
+  });
+  describe('exists', function () {
+    it.each([['exist', {
+      exists: true
+    }, 1, true], ['exist false', {
+      exists: true
+    }, undefined, false], ['nexist', {
+      exists: false
+    }, undefined, true], ['nexist false', {
+      exists: false
+    }, 1, false]])('%s', function (_name, cond, value, expected) {
+      // @ts-ignore
+      expect((0, _includeConditionalArg.testValue)(cond, value)).toBe(expected);
+    });
+  });
+  describe('eq', function () {
+    it.each([['true', {
+      eq: 1
+    }, 1, true], ['false', {
+      eq: 1
+    }, 2, false], ['undefined', {
+      eq: undefined
+    }, undefined, false], ['undefined false', {
+      eq: 1
+    }, undefined, false], ['object true', {
+      eq: {
+        x: 1
+      }
+    }, {
+      x: 1
+    }, true], ['object true', {
+      eq: {
+        x: 1
+      }
+    }, {
+      x: 2
+    }, false]])('%s', function (_name, cond, value, expected) {
+      // @ts-ignore
+      expect((0, _includeConditionalArg.testValue)(cond, value)).toBe(expected);
+    });
+  });
+  describe('neq', function () {
+    it.each([['true', {
+      neq: 1
+    }, 2, true], ['false', {
+      neq: 1
+    }, 1, false], ['undefined true', {
+      neq: 1
+    }, undefined, true], ['undefined false', {
+      neq: undefined
+    }, undefined, false], ['object true', {
+      neq: {
+        x: 1
+      }
+    }, {
+      x: 2
+    }, true], ['object false', {
+      neq: {
+        x: 1
+      }
+    }, {
+      x: 1
+    }, false]])('%s', function (_name, cond, value, expected) {
+      // @ts-ignore
+      expect((0, _includeConditionalArg.testValue)(cond, value)).toBe(expected);
+    });
+  });
+});
+describe('includeConditionalArg', function () {
+  describe('errors', function () {
+    it('should throw if arg and global are both specified', function () {
+      expect(function () {
+        return (0, _includeConditionalArg.includeConditionalArg)({
+          "if": {
+            arg: 'a',
+            global: 'b'
+          }
+        }, {}, {});
+      }).toThrowErrorMatchingInlineSnapshot("\"Invalid conditional value {\\\"arg\\\":\\\"a\\\",\\\"global\\\":\\\"b\\\"}\"");
+    });
+    it('should throw if mulitiple exists / eq / neq are specified', function () {
+      expect(function () {
+        return (0, _includeConditionalArg.includeConditionalArg)({
+          "if": {
+            arg: 'a',
+            exists: true,
+            eq: 1
+          }
+        }, {}, {});
+      }).toThrowErrorMatchingInlineSnapshot("\"Invalid conditional test {\\\"exists\\\":true,\\\"eq\\\":1}\"");
+      expect(function () {
+        return (0, _includeConditionalArg.includeConditionalArg)({
+          "if": {
+            arg: 'a',
+            exists: false,
+            neq: 0
+          }
+        }, {}, {});
+      }).toThrowErrorMatchingInlineSnapshot("\"Invalid conditional test {\\\"exists\\\":false,\\\"neq\\\":0}\"");
+      expect(function () {
+        return (0, _includeConditionalArg.includeConditionalArg)({
+          "if": {
+            arg: 'a',
+            eq: 1,
+            neq: 0
+          }
+        }, {}, {});
+      }).toThrowErrorMatchingInlineSnapshot("\"Invalid conditional test {\\\"eq\\\":1,\\\"neq\\\":0}\"");
+    });
+  });
+  describe('args', function () {
+    describe('implicit', function () {
+      it.each([['implicit true', {
+        "if": {
+          arg: 'a'
+        }
+      }, {
+        a: 1
+      }, {}, true], ['truthy true', {
+        "if": {
+          arg: 'a',
+          truthy: true
+        }
+      }, {
+        a: 0
+      }, {}, false], ['truthy false', {
+        "if": {
+          arg: 'a',
+          truthy: false
+        }
+      }, {}, {}, true]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('exists', function () {
+      it.each([['exist', {
+        "if": {
+          arg: 'a',
+          exists: true
+        }
+      }, {
+        a: 1
+      }, {}, true], ['exist false', {
+        "if": {
+          arg: 'a',
+          exists: true
+        }
+      }, {}, {}, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('eq', function () {
+      it.each([['scalar true', {
+        "if": {
+          arg: 'a',
+          eq: 1
+        }
+      }, {
+        a: 1
+      }, {}, true], ['scalar false', {
+        "if": {
+          arg: 'a',
+          eq: 1
+        }
+      }, {
+        a: 2
+      }, {
+        a: 1
+      }, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('neq', function () {
+      it.each([['scalar true', {
+        "if": {
+          arg: 'a',
+          neq: 1
+        }
+      }, {
+        a: 2
+      }, {}, true], ['scalar false', {
+        "if": {
+          arg: 'a',
+          neq: 1
+        }
+      }, {
+        a: 1
+      }, {
+        a: 2
+      }, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+  });
+  describe('globals', function () {
+    describe('truthy', function () {
+      it.each([['implicit true', {
+        "if": {
+          global: 'a'
+        }
+      }, {}, {
+        a: 1
+      }, true], ['implicit undefined', {
+        "if": {
+          global: 'a'
+        }
+      }, {}, {}, false], ['truthy true', {
+        "if": {
+          global: 'a',
+          truthy: true
+        }
+      }, {}, {
+        a: 0
+      }, false], ['truthy false', {
+        "if": {
+          global: 'a',
+          truthy: false
+        }
+      }, {}, {
+        a: 0
+      }, true]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('exists', function () {
+      it.each([['implicit exist true', {
+        "if": {
+          global: 'a',
+          exists: true
+        }
+      }, {}, {
+        a: 1
+      }, true], ['implicit exist false', {
+        "if": {
+          global: 'a',
+          exists: true
+        }
+      }, {
+        a: 1
+      }, {}, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('eq', function () {
+      it.each([['scalar true', {
+        "if": {
+          global: 'a',
+          eq: 1
+        }
+      }, {}, {
+        a: 1
+      }, true], ['scalar false', {
+        "if": {
+          arg: 'a',
+          eq: 1
+        }
+      }, {
+        a: 2
+      }, {
+        a: 1
+      }, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+    describe('neq', function () {
+      it.each([['scalar true', {
+        "if": {
+          global: 'a',
+          neq: 1
+        }
+      }, {}, {
+        a: 2
+      }, true], ['scalar false', {
+        "if": {
+          global: 'a',
+          neq: 1
+        }
+      }, {
+        a: 2
+      }, {
+        a: 1
+      }, false]])('%s', function (_name, argType, args, globals, expected) {
+        // @ts-ignore
+        expect((0, _includeConditionalArg.includeConditionalArg)(argType, args, globals)).toBe(expected);
+      });
+    });
+  });
+});

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { Args, InputType } from './story';
 export declare const sanitize: (string: string) => string;
 export declare const toId: (kind: string, name?: string | undefined) => string;
 export declare const storyNameFromExport: (key: string) => string;
@@ -16,5 +15,5 @@ export declare const parseKind: (kind: string, { rootSeparator, groupSeparator }
     root: string | null;
     groups: string[];
 };
-export declare const includeConditionalArg: (argType: InputType, args: Args) => boolean;
+export { includeConditionalArg } from './includeConditionalArg';
 export * from './story';

package/dist/index.js

@@ -12,10 +12,18 @@ var _exportNames = {
   includeConditionalArg: true
 };
 exports.isExportStory = isExportStory;
-exports.includeConditionalArg = exports.parseKind = exports.storyNameFromExport = exports.toId = exports.sanitize = void 0;
+Object.defineProperty(exports, "includeConditionalArg", {
+  enumerable: true,
+  get: function get() {
+    return _includeConditionalArg.includeConditionalArg;
+  }
+});
+exports.parseKind = exports.storyNameFromExport = exports.toId = exports.sanitize = void 0;
 
 var _startCase = _interopRequireDefault(require("lodash/startCase"));
 
+var _includeConditionalArg = require("./includeConditionalArg");
+
 var _story = require("./story");
 
 Object.keys(_story).forEach(function (key) {
@@ -126,20 +134,5 @@ var parseKind = function parseKind(kind, _ref2) {
     groups: groups
   };
 };
-/**
- * Helper function to include/exclude an arg based on the value of other other args
- * aka "conditional args"
- */
-
-
-exports.parseKind = parseKind;
-
-var includeConditionalArg = function includeConditionalArg(argType, args) {
-  var addIf = argType.addIf,
-      removeIf = argType.removeIf;
-  if (addIf) return !!args[addIf];
-  if (removeIf) return !args[removeIf];
-  return true;
-};
 
-exports.includeConditionalArg = includeConditionalArg;
+exports.parseKind = parseKind;

package/dist/index.test.js

@@ -139,24 +139,4 @@ describe('isExportStory', function () {
       excludeStories: /b/
     })).toBeTruthy();
   });
-});
-describe('includeConditionalArg', function () {
-  it('dynamic values', function () {
-    expect((0, _.includeConditionalArg)({
-      addIf: 'foo'
-    }, {
-      foo: true
-    })).toBe(true);
-    expect((0, _.includeConditionalArg)({
-      addIf: 'bar'
-    }, {})).toBe(false);
-    expect((0, _.includeConditionalArg)({
-      removeIf: 'foo'
-    }, {
-      foo: true
-    })).toBe(false);
-    expect((0, _.includeConditionalArg)({
-      removeIf: 'bar'
-    }, {})).toBe(true);
-  });
 });

package/dist/story.d.ts

@@ -16,13 +16,27 @@ export interface StoryIdentifier {
 export declare type Parameters = {
     [name: string]: any;
 };
+declare type ConditionalTest = {
+    truthy?: boolean;
+} | {
+    exists: boolean;
+} | {
+    eq: any;
+} | {
+    neq: any;
+};
+declare type ConditionalValue = {
+    arg: string;
+} | {
+    global: string;
+};
+export declare type Conditional = ConditionalValue & ConditionalTest;
 export interface InputType {
     name?: string;
     description?: string;
     defaultValue?: any;
     type?: SBType | SBScalarType['name'];
-    addIf?: string;
-    removeIf?: string;
+    if?: Conditional;
     [key: string]: any;
 }
 export interface StrictInputType extends InputType {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/csf",
-  "version": "0.0.2--canary.507502b.0",
+  "version": "0.0.2--canary.7c6c115.0",
   "description": "Component Story Format (CSF) utilities",
   "keywords": [
     "storybook",
@@ -38,7 +38,10 @@
   },
   "prettier": "@storybook/linter-config/prettier.config",
   "jest": {
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/src"
+    ]
   },
   "dependencies": {
     "lodash": "^4.17.15"