@sanity/tsdoc/dist/exports/store.js

Generate API reference docs from TypeScript projects and store in a Sanity-friendly JSON format. Render a static frontend, or as React components.

"use strict";
Object.defineProperty(exports, "__esModule", { value: !0 });
var groq = require("groq"), groqJs = require("groq-js");
function _interopDefaultCompat(e) {
  return e && typeof e == "object" && "default" in e ? e : { default: e };
}
var groq__default = /* @__PURE__ */ _interopDefaultCompat(groq);
const API_MEMBER_TYPES = [
  "api.class",
  "api.enum",
  "api.function",
  "api.interface",
  "api.namespace",
  "api.typeAlias",
  "api.variable"
], API_EXPORTS_QUERY = groq__default.default`
*[
  _type == 'api.export'
  && package->scope == $packageScope
  && package->name == $packageName
  && release->version == $releaseVersion
]{
  name,
  path,
  package->{name,scope},
  release->{version},
  'isLatest': release->_id == package->latestRelease._ref,
  'members': *[_type in $memberTypes && references(^._id) && !("@hidden" in coalesce(comment.customBlocks[].tag, [])) && !coalesce(isOverloading, false)] | order(name asc) {
    '_key': _id,
    _type,
    comment{deprecated},
    export->{name,path},
    members[]{
      _key,
      _type,
      export->{name,path},
      name,
      package->{name,scope},
      release->{version},
      releaseTag,
      isReactComponentType,
      slug,
    },
    name,
    slug,
    package->{name,scope},
    release->{version},
    releaseTag,
    isReactComponentType,
    isReactHook,
    isOverloading,
  }
} | order(name)
`, API_TOKEN_MEMBER_PROJECTION = groq__default.default`
...,
export->{name, path},
package->{name, scope},
release->{version}
`, API_CLASS_PROJECTION = groq__default.default`
_id,
_type,
_updatedAt,
comment,
export->{name,path},
members[]{
  _type == 'api.constructor' => {
    _key,
    _type,
    comment,
    parameters[]{
      _key,
      _type,
      name,
      releaseTag,
      type[]{
        ...,
        member->{${API_TOKEN_MEMBER_PROJECTION}}
      }
    },
    releaseTag
  },
  _type == 'api.method' => {
    _key,
    _type,
    comment,
    name,
    isOptional,
    isStatic,
    parameters[]{
      _key,
      _type,
      name,
      releaseTag,
      type[]{
        ...,
        member->{${API_TOKEN_MEMBER_PROJECTION}}
      }
    },
    releaseTag,
    returnType[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    },
    typeParameters
  },
  _type == 'api.property' => {
    _key,
    _type,
    comment,
    name,
    isEventProperty,
    isOptional,
    isStatic,
    releaseTag,
    type[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    }
  }
},
name,
package->{scope,name},
release->{version},
releaseTag,
typeParameters
`, API_ENUM_PROJECTION = groq__default.default`
...,
export->{name,path},
package->{scope,name},
release->{version}
`, API_INTERFACE_PROJECTION = groq__default.default`
_id,
_type,
_updatedAt,
comment,
export->{name,path},
extends,
members[]{
  _type == 'api.callSignature' => {
    _key,
    _type,
    comment,
    parameters[]{
      _key,
      _type,
      name,
      releaseTag,
      type[]{
        ...,
        member->{${API_TOKEN_MEMBER_PROJECTION}}
      }
    },
    releaseTag,
    returnType[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    },
    typeParameters
  },

  _type == 'api.methodSignature' => {
    _key,
    _type,
    comment,
    isOptional,
    name,
    parameters[]{
      _key,
      _type,
      name,
      releaseTag,
      type[]{
        ...,
        member->{${API_TOKEN_MEMBER_PROJECTION}}
      }
    },
    releaseTag,
    returnType[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    },
    typeParameters
  },

  _type == 'api.indexSignature' => {
    _key,
    _type,
    comment,
    releaseTag,
    parameters[]{
      _key,
      _type,
      name,
      releaseTag,
      type[]{
        ...,
        member->{${API_TOKEN_MEMBER_PROJECTION}}
      }
    },
    returnType[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    }
  },

  _type == 'api.propertySignature' => {
    _key,
    _type,
    comment,
    isOptional,
    name,
    releaseTag,
    comment,
    type[]{
      ...,
      member->{${API_TOKEN_MEMBER_PROJECTION}}
    }
  }
},
name,
package->{scope,name},
'referrers': *[references(^._id)] {
  _type,
  name,
  export->{path},
  package->{scope,name},
  release->{version}
},
release->{version},
releaseTag,
slug,
typeParameters
`, API_FUNCTION_PROJECTION = groq__default.default`
_id,
_type,
_updatedAt,
comment,
export->{name,path},
isReactComponentType,
name,
package->{scope,name},
parameters[]{
  _key,
  _type,
  name,
  releaseTag,
  comment,
  type[]{
    ...,
    member->{${API_TOKEN_MEMBER_PROJECTION}}
  }
},
propsType->{
  _type == 'api.interface' => {
    ${API_INTERFACE_PROJECTION}
  }
},
'referrers': *[references(^._id)] {
  _type,
  name,
  export->{path},
  package->{scope,name},
  release->{version}
},
release->{version},
releaseTag,
returnType[]{
  ...,
  member->{${API_TOKEN_MEMBER_PROJECTION}}
},
typeParameters
`, API_NAMESPACE_PROJECTION = groq__default.default`
_id,
_type,
_updatedAt,
comment,
export->{name,path},
members[]{
  ...
},
name,
package->{scope,name},
release->{version},
releaseTag
`, API_TYPE_ALIAS_PROJECTION = groq__default.default`
_id,
_type,
_updatedAt,
comment,
export->{name,path},
name,
package->{scope,name},
release->{version},
releaseTag,
type[]{
  ...,
  member->{${API_TOKEN_MEMBER_PROJECTION}}
},
typeParameters
`, API_VARIABLE_PROJECTION = groq__default.default`
_id,
_type,
comment,
export->{name,path},
isReactComponentType,
name,
parameters[]{
  _key,
  _type,
  name,
  releaseTag,
  comment,
  type[]{
    ...,
    member->{${API_TOKEN_MEMBER_PROJECTION}}
  }
},
package->{scope,name},
propsType->,
release->{version},
releaseTag,
'referrers': *[references(^._id)] {
  _type,
  name,
  export->{path},
  package->{scope,name},
  release->{version}
},
type[]{
  ...,
  member->{${API_TOKEN_MEMBER_PROJECTION}}
}
`, API_MEMBER_PROJECTION = groq__default.default`
_type == 'api.class' => {
  ${API_CLASS_PROJECTION}
},

_type == 'api.enum' => {
  ${API_ENUM_PROJECTION}
},

_type == 'api.function' => {
  ${API_FUNCTION_PROJECTION}
},

_type == 'api.interface' => {
  ${API_INTERFACE_PROJECTION}
},

_type == 'api.namespace' => {
  ${API_NAMESPACE_PROJECTION}
},

_type == 'api.typeAlias' => {
  ${API_TYPE_ALIAS_PROJECTION}
},

_type == 'api.variable' => {
  ${API_VARIABLE_PROJECTION}
}
`, API_MEMBER_QUERY = groq__default.default`
*[
  _type in $memberTypes
  && export->path == $exportPath
  && package->scope == $packageScope
  && package->name == $packageName
  && release->version == $releaseVersion
  && slug.current == $memberSlug
  && !("@hidden" in coalesce(comment.customBlocks[].tag, []))
]{
  ${API_MEMBER_PROJECTION},
  "members": members[!("@hidden" in coalesce(comment.customBlocks[].tag, []))],
  'versions': *[
    _type == 'api.release'
    && package->scope == $packageScope
    && package->name == $packageName
  ]{version}.version
}
`, NON_HIDDEN_MEMBER_TYPES_ARRAY = groq__default.default`*[
  _type in $memberTypes
  && name == ^.name
  && package->scope == $packageScope
  && package->name == $packageName
  && !("@hidden" in coalesce(comment.customBlocks[].tag, []))
]`, API_SYMBOL_SEARCH_QUERY = groq__default.default`
*[
  _type == 'api.symbol'
  && name match $query
  && package->scope == $packageScope
  && package->name == $packageName
  && count(${NON_HIDDEN_MEMBER_TYPES_ARRAY}) > 0
]{
  _id,
  _type,
  name,
  package->{name,scope}
}[0...10]{
  ...,
  'members': ${NON_HIDDEN_MEMBER_TYPES_ARRAY}{
    slug,
    'exportPath': export->path,
    'releaseVersion': release->version
  }
} | order(lower(name) asc)
`, API_PACKAGES_QUERY = groq__default.default`
*[_type == 'api.package']{
  _id,
  name,
  scope,
  latestRelease->{version},
  releases[]->{version}
}
`, API_PACKAGE_QUERY = groq__default.default`
*[
  _type == 'api.package'
  && scope == $packageScope
  && name == $packageName
][0]
`, API_SYMBOL_QUERY = groq__default.default`
*[
  _type == 'api.symbol'
  && package->scope == $packageScope
  && package->name == $packageName
]{
  _type,
  name,
  package->{name,scope},
  'members': *[
    _type in $memberTypes
  ]{${API_MEMBER_PROJECTION}}
}[0]
`;
function createTSDocStore(options) {
  const { debug, query, initialState } = options, cache = initialState || {
    exports: {},
    member: {},
    package: {},
    packages: [],
    symbol: {}
  };
  return {
    exports: {
      get: async (params) => {
        debug && console.log("exports.get", params);
        const key = JSON.stringify(params);
        if (cache.exports[key])
          return debug && console.log("exports.get read from cache"), cache.exports[key];
        const result = await query(API_EXPORTS_QUERY, {
          ...params,
          memberTypes: API_MEMBER_TYPES
        });
        return cache.exports[key] = result, result;
      }
    },
    member: {
      get: async (params) => {
        debug && console.log("member.get", params);
        const key = JSON.stringify(params);
        if (cache.member[key])
          return debug && console.log("member.get read from cache"), cache.member[key];
        const result = await query(API_MEMBER_QUERY, {
          ...params,
          memberTypes: API_MEMBER_TYPES
        });
        return cache.member[key] = result, result;
      }
    },
    package: {
      get: async (params) => {
        debug && console.log("package.get", params);
        const key = JSON.stringify(params);
        if (cache.package[key])
          return debug && console.log("package.get read from cache"), cache.package[key];
        const result = await query(API_PACKAGE_QUERY, {
          ...params,
          memberTypes: API_MEMBER_TYPES
        });
        return cache.package[key] = result, result;
      }
    },
    packages: {
      get: async () => {
        if (debug && console.log("packages.get"), cache.packages.length)
          return debug && console.log("packages.get read from cache"), cache.packages;
        const result = await query(API_PACKAGES_QUERY, {});
        return cache.packages = result, result;
      }
    },
    symbol: {
      get: async (params) => {
        debug && console.log("symbol.get", params);
        const key = JSON.stringify(params);
        if (cache.symbol[key])
          return debug && console.log("symbol.get read from cache"), cache.symbol[key];
        const result = await query(API_SYMBOL_QUERY, {
          ...params,
          memberTypes: API_MEMBER_TYPES
        });
        return cache.symbol[key] = result, result;
      },
      search: (params) => (debug && console.log("symbol.search", params), query(API_SYMBOL_SEARCH_QUERY, {
        ...params,
        memberTypes: API_MEMBER_TYPES,
        query: `*${params.query}*`
      }))
    }
  };
}
const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), DEBUG = !1;
function createTSDocMemoryStore({ docs }) {
  return createTSDocStore({ debug: DEBUG, query: async (q, params) => {
    await delay(0);
    const tree = groqJs.parse(q);
    return await (await groqJs.evaluate(tree, {
      dataset: docs,
      params
    })).get();
  } });
}
exports.API_EXPORTS_QUERY = API_EXPORTS_QUERY;
exports.API_MEMBER_PROJECTION = API_MEMBER_PROJECTION;
exports.API_MEMBER_QUERY = API_MEMBER_QUERY;
exports.API_MEMBER_TYPES = API_MEMBER_TYPES;
exports.API_PACKAGES_QUERY = API_PACKAGES_QUERY;
exports.API_PACKAGE_QUERY = API_PACKAGE_QUERY;
exports.API_SYMBOL_QUERY = API_SYMBOL_QUERY;
exports.API_SYMBOL_SEARCH_QUERY = API_SYMBOL_SEARCH_QUERY;
exports.createTSDocMemoryStore = createTSDocMemoryStore;
exports.createTSDocStore = createTSDocStore;
//# sourceMappingURL=store.js.map