@storybook/csf 0.0.2--canary.0899bb7.0 → 0.0.2--canary.50.794a0bf.0

package/dist/index.d.ts

@@ -15,5 +15,4 @@ export declare const parseKind: (kind: string, { rootSeparator, groupSeparator }
     root: string | null;
     groups: string[];
 };
-export { includeConditionalArg } from './includeConditionalArg';
 export * from './story';

package/dist/index.js

@@ -8,22 +8,13 @@ var _exportNames = {
   toId: true,
   storyNameFromExport: true,
   isExportStory: true,
-  parseKind: true,
-  includeConditionalArg: true
+  parseKind: true
 };
 exports.isExportStory = isExportStory;
-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) {

package/dist/story.d.ts

@@ -16,27 +16,11 @@ 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'];
-    if?: Conditional;
     [key: string]: any;
 }
 export interface StrictInputType extends InputType {
@@ -93,26 +77,20 @@ export declare type StoryContext<TFramework extends AnyFramework = AnyFramework,
     abortSignal: AbortSignal;
     canvasElement: HTMLElement;
 };
-export declare type StepLabel = string;
-export declare type StepFunction<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (label: StepLabel, play: PlayFunction<TFramework, TArgs>) => void;
-export declare type PlayFunctionContext<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = StoryContext<TFramework, TArgs> & {
-    step: StepFunction<TFramework, TArgs>;
-};
-export declare type PlayFunction<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (context: PlayFunctionContext<TFramework, TArgs>) => Promise<void> | void;
+export declare type PlayFunction<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (context: StoryContext<TFramework, TArgs>) => Promise<void> | void;
 export declare type PartialStoryFn<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (update?: StoryContextUpdate<TArgs>) => TFramework['storyResult'];
 export declare type LegacyStoryFn<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (context: StoryContext<TFramework, TArgs>) => TFramework['storyResult'];
 export declare type ArgsStoryFn<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (args: TArgs, context: StoryContext<TFramework, TArgs>) => TFramework['storyResult'];
 export declare type StoryFn<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = LegacyStoryFn<TFramework, TArgs> | ArgsStoryFn<TFramework, TArgs>;
 export declare type DecoratorFunction<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (fn: PartialStoryFn<TFramework, TArgs>, c: StoryContext<TFramework, TArgs>) => TFramework['storyResult'];
 export declare type DecoratorApplicator<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (storyFn: LegacyStoryFn<TFramework, TArgs>, decorators: DecoratorFunction<TFramework, TArgs>[]) => LegacyStoryFn<TFramework, TArgs>;
-export declare type StepRunner<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = (label: StepLabel, play: PlayFunction<TFramework, TArgs>, context: PlayFunctionContext<TFramework, TArgs>) => Promise<void>;
 export declare type BaseAnnotations<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = {
     decorators?: DecoratorFunction<TFramework, Args>[];
     parameters?: Parameters;
     args?: Partial<TArgs>;
     argTypes?: Partial<ArgTypes<TArgs>>;
     loaders?: LoaderFunction<TFramework, Args>[];
-    render?: ArgsStoryFn<TFramework, TArgs>;
+    render?: ArgsStoryFn<TFramework, Args>;
 };
 export declare type ProjectAnnotations<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = BaseAnnotations<TFramework, TArgs> & {
     argsEnhancers?: ArgsEnhancer<TFramework, Args>[];
@@ -120,7 +98,6 @@ export declare type ProjectAnnotations<TFramework extends AnyFramework = AnyFram
     globals?: Globals;
     globalTypes?: GlobalTypes;
     applyDecorators?: DecoratorApplicator<TFramework, Args>;
-    runStep?: StepRunner<TFramework, TArgs>;
 };
 declare type StoryDescriptor = string[] | RegExp;
 export declare type ComponentAnnotations<TFramework extends AnyFramework = AnyFramework, TArgs = Args> = BaseAnnotations<TFramework, TArgs> & {

package/dist/story.test.js

@@ -1,9 +1,5 @@
 "use strict";
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
 // NOTE Example of internal type definition for @storybook/<X> (where X is a framework)
 // NOTE Examples of using types from @storybook/<X> in real project
 var Button = function Button() {
@@ -120,7 +116,7 @@ CSF2Story.args = {
   a: 1
 };
 var CSF3Story = {
-  render: function render(args) {
+  render: function render() {
     return 'Named Story';
   },
   name: 'Another name for story',
@@ -142,7 +138,7 @@ var CSF3Story = {
   }
 };
 var CSF3StoryStrict = {
-  render: function render(args) {
+  render: function render() {
     return 'Named Story';
   },
   name: 'Another name for story',
@@ -161,31 +157,6 @@ var CSF3StoryStrict = {
   }],
   args: {
     x: '1'
-  },
-  play: function play(_ref) {
-    var step = _ref.step;
-    step('a step', function (_ref2) {
-      var substep = _ref2.step;
-      substep('a substep', function () {});
-    });
-  }
-};
-var project = {
-  runStep: function runStep(label, play, context) {
-    return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
-      return regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", play(context));
-
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }))();
   }
 }; // NOTE Jest forced to define at least one test in file
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/csf",
-  "version": "0.0.2--canary.0899bb7.0",
+  "version": "0.0.2--canary.50.794a0bf.0",
   "description": "Component Story Format (CSF) utilities",
   "keywords": [
     "storybook",
@@ -38,15 +38,13 @@
   },
   "prettier": "@storybook/linter-config/prettier.config",
   "jest": {
-    "testEnvironment": "node",
-    "roots": [
-      "<rootDir>/src"
-    ]
+    "testEnvironment": "node"
   },
   "dependencies": {
     "lodash": "^4.17.15"
   },
   "devDependencies": {
+    "@auto-it/released": "^10.37.1",
     "@babel/cli": "^7.8.4",
     "@babel/core": "^7.9.0",
     "@babel/preset-env": "^7.9.5",
@@ -63,6 +61,12 @@
     "prettier": "^1.19.1",
     "typescript": "^3.7.2"
   },
+  "auto": {
+    "plugins": [
+      "npm",
+      "released"
+    ]
+  },
   "publishConfig": {
     "access": "public"
   }

package/dist/includeConditionalArg.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,74 +0,0 @@
-"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.js

@@ -1,318 +0,0 @@
-"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);
-      });
-    });
-  });
-});