@miso.ai/client-sdk-codegen 1.11.6-beta.0 → 1.11.6-beta.1

package/dist/cjs/ui/search.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.search = search;
+var _presets = require("../spec/presets.js");
+var _helpers = require("../template/helpers.js");
+var _index = require("../template/index.js");
+var _features = require("../template/features.js");
+const _excluded = ["facets"];
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function normalizeOptions(_ref = {}) {
+  let {
+      facets
+    } = _ref,
+    options = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (facets === true) {
+    facets = ['categories'];
+  }
+  return Object.assign({}, options, {
+    facets
+  });
+}
+function search(options) {
+  options = normalizeOptions((0, _helpers.resolvePreset)(_presets.search, options));
+  // TODO: extra styles for concatenate format
+  const items = [];
+  if (options.elements !== false) {
+    items.push({
+      type: 'html',
+      name: 'HTML (Search box)',
+      content: htmlSearchBox(options)
+    }, {
+      type: 'html',
+      name: 'HTML (Results)',
+      content: htmlResults(options)
+    });
+  }
+  items.push({
+    type: 'js',
+    name: 'JavaScript',
+    content: js(options)
+  });
+  return items;
+}
+function js(options) {
+  // TODO: support loading from Node module
+  return (0, _index.misocmd)(`
+// client
+${(0, _index.createClient)(options)}
+
+// workflow
+const workflow = client.ui.search;
+
+// setup: TODO
+${(0, _features.facets)(options.facets)}
+
+${(0, _features.autoQuery)(options.autoQuery)}
+`);
+}
+function html(options) {
+  if (options.elements === false) {
+    return '';
+  }
+  return `
+${htmlSearchBox(options)}
+<hr>
+${htmlResults(options)}
+`.trim();
+}
+function htmlSearchBox(options) {
+  return `
+<miso-search>
+  <miso-query></miso-query>
+</miso-search>
+`.trim();
+}
+function htmlResults(options) {
+  // TODO: useLink
+  return `
+<miso-search visible-when="loading ready">
+  <div class="info">
+    <div class="keywords">You searched for “<miso-keywords></miso-keywords>”</div>
+    <div class="total"><miso-total></miso-total> Results</div>
+  </div>
+  <miso-facets></miso-facets>
+  <miso-products></miso-products>
+</miso-search>
+`.trim();
+}

package/dist/cjs/ui/ui.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ui = ui;
+var _hybridSearch = require("./hybrid-search.js");
+var _search = require("./search.js");
+const _excluded = ["workflow"];
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+const workflows = {
+  ['hybrid-search']: _hybridSearch.hybridSearch,
+  search: _search.search
+};
+function normalizeOptions(_ref = {}) {
+  let {
+      workflow
+    } = _ref,
+    options = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (!workflow) {
+    throw new Error('Workflow is required');
+  }
+  return Object.assign({
+    workflow
+  }, options);
+}
+function ui(options) {
+  options = normalizeOptions(options);
+  const {
+    workflow
+  } = options;
+  if (!workflows[workflow]) {
+    throw new Error(`Workflow "${workflow}" is not found`);
+  }
+  return workflows[workflow](options);
+}

package/package.json

@@ -26,7 +26,7 @@
     "url": "https://github.com/MisoAI/miso-client-js-sdk/issues"
   },
   "dependencies": {
-    "@miso.ai/commons": "1.11.6-beta.0"
+    "@miso.ai/commons": "1.11.6-beta.1"
   },
-  "version": "1.11.6-beta.0"
+  "version": "1.11.6-beta.1"
 }

package/src/codegen.js

@@ -1,23 +1,11 @@
-import * as workflows from './workflow/index.js';
+import { ui } from './ui/index.js';
+import Output from './output.js';
 
-function normalizeOptions({ workflow, ...options } = {}) {
-  // turn workflow into camel case
-  if (!workflow) {
-    throw new Error('Workflow is required');
+export function codegen({ schema = 'ui', ...options } = {}) {
+  switch (schema) {
+    case 'ui':
+      return new Output(ui(options));
+    default:
+      throw new Error(`Unrecognized schema: "${schema}"`);
   }
-  workflow = workflow.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-
-  return {
-    workflow,
-    ...options,
-  };
-}
-
-export function codegen(options) {
-  options = normalizeOptions(options);
-  const { workflow } = options;
-  if (!workflows[workflow]) {
-    throw new Error(`Workflow "${workflow}" is not found`);
-  }
-  return workflows[workflow](options);
 }

package/src/index.js

@@ -1,4 +1,4 @@
+export * as spec from './spec/index.js';
 export * from './params.js';
 export * from './codegen.js';
-export * from './spec/index.js';
-export * as workflows from './workflow/index.js';
+export * as ui from './ui/index.js';

package/src/output.js

@@ -0,0 +1,33 @@
+export default class Output {
+
+  constructor(items) {
+    this._items = items;
+  }
+
+  get items() {
+    return this._items;
+  }
+
+  [Symbol.iterator]() {
+    return this._items[Symbol.iterator]();
+  }
+
+  concat() {
+    return this._items.filter(item => item).map(item => asHtml(item)).join('\n');
+  }
+
+}
+
+function asHtml({ type, content } = {}) {
+  // TODO: minify
+  switch (type) {
+    case 'html':
+      return content;
+    case 'js':
+      return `<script async>\n${content}\n</script>`;
+    case 'css':
+      return `<style>\n${content}\n</style>`;
+    default:
+      throw new Error(`Unrecognized type: "${type}"`);
+  }
+}

package/src/params.js

@@ -1,11 +1,20 @@
-export function encodeParameters(params = {}) {
+export function encodeParameters(params) {
+  if (params === undefined || params === null) {
+    return undefined;
+  }
+  if (typeof params !== 'object') {
+    throw new Error('params must be an object');
+  }
   // JSON string -> base64
   return base64Encode(JSON.stringify(params));
 }
 
 export function decodeParameters(params) {
+  if (params === undefined || params === null) {
+    return undefined;
+  }
   // base64 -> JSON string
-  return params ? JSON.parse(base64Decode(params)) : {};
+  return JSON.parse(base64Decode(params));
 }
 
 function base64Encode(str) {

package/src/spec/features.js

@@ -1,43 +1,41 @@
-import { resolveWorkflows } from './workflows.js';
+import { toName } from './utils.js';
+import { resolveWorkflows } from './workflows.slug.js';
 
-export const FEATURES = [
+export default [
   {
     slug: 'use-api',
-    name: 'useApi()',
-    workflows: resolveWorkflows('*'),
+    workflows: '*',
   },
   {
     slug: 'use-link',
-    name: 'useLink()',
-    workflows: resolveWorkflows('ahes'),
+    workflows: 'ahes',
   },
   {
-    slug: 'follow-up',
-    name: 'Follow Up',
-    workflows: resolveWorkflows('a'),
+    slug: 'autocomplete',
+    workflows: 'hs',
   },
   {
-    slug: 'auto-query',
-    name: 'Auto Query',
-    workflows: resolveWorkflows('ahes'),
+    slug: 'pagination',
+    workflows: 'hs',
   },
   {
-    slug: 'autocomplete',
-    name: 'Autocomplete',
-    workflows: resolveWorkflows('hs'),
+    slug: 'facets',
+    workflows: 'hs',
   },
   {
-    slug: 'pagination',
-    name: 'Pagination',
-    workflows: resolveWorkflows('hs'),
+    slug: 'follow-up',
+    workflows: 'a',
   },
   {
-    slug: 'facets',
-    name: 'Facets',
-    workflows: resolveWorkflows('hs'),
+    slug: 'auto-query',
+    workflows: 'ahes',
   },
-];
-
-export function getFeatures(workflow) {
-  return FEATURES.filter(feature => feature.workflows.includes(workflow));
-}
+].reduce((map, { slug, workflows, ...rest }) => {
+  map[slug] = Object.freeze({
+    slug,
+    name: toName(slug),
+    workflows: resolveWorkflows(workflows),
+    ...rest,
+  });
+  return map;
+}, {});

package/src/spec/index.js

@@ -1,5 +1,2 @@
-import { presets as hybridSearchPresets } from '../workflow/hybrid-search.js';
-
-export const presets = Object.freeze({
-  hybridSearch: Object.keys(hybridSearchPresets),
-});
+export { default as workflows } from './workflows.js';
+export { default as features } from './features.js';

package/src/spec/presets.js

@@ -0,0 +1,24 @@
+export const hybridSearch = Object.freeze({
+  standard: Object.freeze({
+    workflow: 'hybrid-search',
+    autoQuery: true,
+    autocomplete: true,
+    facets: ['categories'],
+    answerBox: true,
+  }),
+  minimal: Object.freeze({
+    workflow: 'hybrid-search',
+  }),
+});
+
+export const search = Object.freeze({
+  standard: Object.freeze({
+    workflow: 'search',
+    autoQuery: true,
+    autocomplete: true,
+    //facets: ['categories'],
+  }),
+  minimal: Object.freeze({
+    workflow: 'search',
+  }),
+});

package/src/spec/utils.js

@@ -0,0 +1,5 @@
+import { kebabOrSnakeToHuman, capitalize } from '@miso.ai/commons';
+
+export function toName(str) {
+  return capitalize(kebabOrSnakeToHuman(str));
+}

package/src/spec/workflows.js

@@ -1,39 +1,27 @@
-import { kebabOrSnakeToHuman } from '@miso.ai/commons';
+import { kebabToLowerCamel } from '@miso.ai/commons';
+import { toName } from './utils.js';
+import { WORKFLOW_SLUGS } from './workflows.slug.js';
+import features from './features.js';
+import * as presets from './presets.js';
 
-export const WORKFLOWS = ([
-  {
-    slug: 'ask',
-  },
-  {
-    slug: 'hybrid-search',
-  },
-  {
-    slug: 'explore',
-  },
-  {
-    slug: 'search',
-  },
-  {
-    slug: 'recommendation',
-  },
-]).map(workflow => ({
-  ...workflow,
-  name: kebabOrSnakeToHuman(workflow.slug),
-}));
+function getFeatures(features, slug) {
+  return Object.values(features).filter(feature => feature.workflows.includes(slug));
+}
 
-const ABV_TO_WORKFLOW = WORKFLOWS.reduce((map, workflow) => {
-  map[workflow.slug.charAt(0)] = workflow;
-  return map;
-}, {});
+function getPresets(presets, slug) {
+  return Object.entries(presets[kebabToLowerCamel(slug)] || {}).map(([key, value]) => Object.freeze({
+    slug: key,
+    name: toName(key),
+    value,
+  }));
+}
 
-export function resolveWorkflows(abvs) {
-  if (abvs === '*') {
-    return [...WORKFLOWS];
-  }
-  return abvs.split('').map(abv => {
-    if (!ABV_TO_WORKFLOW[abv]) {
-      throw new Error(`Workflow "${abv}" is not found`);
-    }
-    return ABV_TO_WORKFLOW[abv];
+export default WORKFLOW_SLUGS.reduce((obj, slug) => {
+  obj[slug] = Object.freeze({
+    slug,
+    name: toName(slug),
+    features: getFeatures(features, slug),
+    presets: getPresets(presets, slug),
   });
-}
+  return obj;
+}, {});

package/src/spec/workflows.slug.js

@@ -0,0 +1,24 @@
+export const WORKFLOW_SLUGS = [
+  'ask',
+  'hybrid-search',
+  'explore',
+  'search',
+  'recommendation',
+];
+
+const ABV_TO_WORKFLOW = WORKFLOW_SLUGS.reduce((map, slug) => {
+  map[slug.charAt(0)] = slug;
+  return map;
+}, {});
+
+export function resolveWorkflows(abvs) {
+  if (abvs === '*') {
+    return [...WORKFLOW_SLUGS];
+  }
+  return abvs.split('').map(abv => {
+    if (!ABV_TO_WORKFLOW[abv]) {
+      throw new Error(`Workflow "${abv}" is not found`);
+    }
+    return ABV_TO_WORKFLOW[abv];
+  });
+}

package/src/template/client.js

@@ -0,0 +1,25 @@
+import { indent, blocks } from './helpers.js';
+
+export function createClient(options) {
+  return blocks(
+    `const MisoClient = window.MisoClient;`,
+    ...clientPlugins(options),
+    `const client = new MisoClient(${clientOptions(options)});`
+  );
+}
+
+function clientPlugins({ dryRun } = {}) {
+  const blocks = [];
+  if (dryRun) {
+    blocks.push(`MisoClient.plugins.use("std:dry-run");`);
+  }
+  return blocks;
+}
+
+function clientOptions({ apiKey, apiKeyParam = false } = {}) {
+  if (!apiKeyParam) {
+    return `'${apiKey}'`;
+  }
+  apiKeyParam = apiKeyParam === true ? 'api-key' : apiKeyParam;
+  return `new URLSearchParams(window.location.search).get('${apiKeyParam}') || '${apiKey}'`;
+}

package/src/template/entrypoints.js

@@ -0,0 +1,10 @@
+import { indent } from './helpers.js';
+
+export function misocmd(body) {
+  return `
+const misocmd = window.misocmd || (window.misocmd = []);
+misocmd.push(async () => {
+${indent(body, 2)}
+});
+`.trim();
+}

package/src/template/features.js

@@ -0,0 +1,10 @@
+import { format } from './helpers.js';
+
+export function facets(options) {
+  return options ? `workflow.useFacets(${format(options, { multiline: true })});` : '';
+}
+
+export function autoQuery(options) {
+  // TODO: consider when options === false
+  return options ? `workflow.autoQuery(${typeof options === 'object' ? format(options, { multiline: true }) : ''});` : '';
+}

package/src/{utils.js → template/helpers.js}

@@ -1,4 +1,5 @@
 export function indent(str, level = 1) {
+  // TODO: trim and deal with blank lines
   return str.replace(/\n/g, '\n' + ' '.repeat(level));
 }
 
@@ -15,6 +16,24 @@ export function format(value, { multiline = false } = {}) {
   return JSON.stringify(value, null, multiline ? 2 : 0).replace(/"/g, "'").replace(/\s*:\s*/g, ': ');
 }
 
+/**
+ * Join blocks with proper newlines
+ * @param {string[]} blocks - Blocks to join
+ * @returns {string}
+ */
+export function blocks(...blocks) {
+  return blocks.map(block => block.trim()).filter(block => block).join('\n');
+}
+
+/**
+ * Join paragraphs with proper newlines
+ * @param {string[]} paragraphs - Paragraphs to join
+ * @returns {string}
+ */
+export function paragraphs(...paragraphs) {
+  return paragraphs.map(paragraph => paragraph.trim()).filter(paragraph => paragraph).join('\n\n');
+}
+
 /**
  * Resolve preset options
  * @param {Object} presets - Available presets

package/src/template/index.js

@@ -0,0 +1,4 @@
+export * from './entrypoints.js';
+export * from './client.js';
+export * as features from './features.js';
+export * as helpers from './helpers.js';

package/src/ui/hybrid-search.js

@@ -0,0 +1,71 @@
+import { hybridSearch as presets } from '../spec/presets.js';
+import { resolvePreset } from '../template/helpers.js';
+import { misocmd, createClient } from '../template/index.js';
+import { autoQuery } from '../template/features.js';
+
+// TODO: refactor these
+function normalizeOptions({ facets, ...options } = {}) {
+  if (facets === true) {
+    facets = ['categories'];
+  }
+  return {
+    ...options,
+    facets,
+  };
+}
+
+export function hybridSearch(options) {
+  options = normalizeOptions(resolvePreset(presets, options));
+  const items = [
+    {
+      type: 'html',
+      name: 'HTML',
+      content: html(options),
+    },
+    {
+      type: 'js',
+      name: 'JavaScript',
+      content: js(options),
+    },
+  ];
+  return items;
+}
+
+function js(options) {
+  // TODO: support loading from Node module
+  // TODO: useLink
+  return misocmd(`
+// client
+${createClient(options)}
+
+// workflow
+const workflow = client.ui.hybridSearch;
+
+// setup: TODO
+
+${jsElements(options)}
+
+${autoQuery(options.autoQuery)}
+`);
+}
+
+function jsElements(options) {
+  if (options.elements === false) {
+    return '';
+  }
+  return `
+// render Miso elements
+await client.ui.ready;
+const { templates, wireAnswerBox } = MisoClient.ui.defaults.hybridSearch;
+const rootElement = document.querySelector('#miso-hybrid-search-combo');
+rootElement.innerHTML = templates.root();
+wireAnswerBox(client, rootElement);
+`.trim();
+}
+
+function html(options) {
+  if (options.elements === false) {
+    return '';
+  }
+  return `<div id="miso-hybrid-search-combo" class="miso-hybrid-search-combo"></div>`.trim();
+}

package/src/ui/index.js

@@ -0,0 +1,3 @@
+export * from './hybrid-search.js';
+export * from './search.js';
+export * from './ui.js';