@progress/kendo-typescript-tasks 11.2.7-dev.0 → 11.2.7-dev.12

package/src/api/property.hbs

@@ -1,38 +0,0 @@
-<tr>
-<td class="table-cell-name">
-
-
-#### {{name}}
-
-
-</td>
-<td type class="table-cell-type">
-
-
-{{> code_block type }}
-
-
-</td>
-<td class="table-cell-default">
-
-
-{{#if defaultValue}}
-<code>
-
-
-{{defaultValue}}
-
-
-</code>
-{{/if}}
-
-
-</td>
-<td class="table-cell-comment">
-
-
-{{comment}}
-
-
-</td>
-</tr>

package/src/api/react/component-page.hbs

@@ -1,26 +0,0 @@
-{{> member_meta}}
-
-# {{name}}
-{{comment}}
-
-{{#if properties}}
-
-<table class="api-table api-table-properties">
-<thead>
-<tr>
-<th class="th-name">Name</th>
-<th class="th-type">Type</th>
-<th class="th-default">Default</th>
-<th class="th-desc">Description</th>
-</tr>
-</thead>
-<tbody class="api-table-body">
-{{#each properties}}
-{{> property this }}
-{{/each}}
-</tbody>
-</table>
-
-{{/if}}
-
-{{> methods}}

package/src/api/react/component-page.js

@@ -1,30 +0,0 @@
-"use strict";
-
-const template = require('./../template-utils.js');
-const comment = require('./../comment.js');
-const mapProps = require('./../map-props.js');
-const mapMethods = require('./../map-methods.js');
-const isField = require('./../is-field.js');
-
-const componentTemplate = template.compileFrom('./react/component-page.hbs');
-template.partialFrom('member_meta', 'member-meta.hbs');
-template.partialFrom('methods', 'methods.hbs');
-
-const componentPage = (component, meta) => {
-    let properties;
-    let methods;
-    if (component.children) {
-        properties = mapProps(component.children.filter(isField), component.name);
-        methods = mapMethods(component.children, component.name);
-    }
-
-    return componentTemplate(Object.assign({}, meta, {
-        name: component.name,
-        comment: comment(component),
-        properties: properties,
-        methods: methods,
-        slug: component.slug
-    }));
-};
-
-module.exports = componentPage;

package/src/api/return-type.js

@@ -1,30 +0,0 @@
-"use strict";
-
-const types = require('./type-utils.js');
-const utils = require('./utils.js');
-
-const returnType = (definition, parentName) => {
-    if (definition.type.name === 'void') {
-        return undefined;
-    }
-
-    let comment;
-    if (definition.comment) {
-        comment = definition.comment.returns;
-    }
-
-    if (!comment && definition.type.name !== 'void') {
-        let source = `${definition.name}`;
-        if (parentName) {
-            source = `${parentName } - ${source}`;
-        }
-        utils.warn('Undocumented return type', source);
-    }
-
-    return {
-        type: types.typeString(definition),
-        comment: comment
-    };
-};
-
-module.exports = returnType;

package/src/api/slug.js

@@ -1,9 +0,0 @@
-"use strict";
-
-const slug = (packageName, memberName) => [
-    'api',
-    packageName.replace(/.*\//, '').replace(/kendo-(angular|react|vue)-/, ''),
-    (memberName || '').toLowerCase()
-].filter(p => p).join('_');
-
-module.exports = slug;

package/src/api/template-utils.js

@@ -1,40 +0,0 @@
-"use strict";
-
-const fs = require('fs');
-const path = require('path');
-const hbs = require('handlebars');
-
-hbs.registerHelper('capitalize',
-    s => s.slice(0,1).toUpperCase() + s.slice(1));
-
-hbs.registerHelper('lowercase',
-    s => s.toLowerCase());
-
-hbs.registerHelper('contains',
-    (s, chars, options) => (s.includes(chars) ? options.fn(s) : options.inverse(s)));
-
-hbs.registerHelper('equals',
-    (s, comparer, options) => (s === comparer ? options.fn(s) : options.inverse(s)));
-
-const readLocal = (src) =>
-    fs.readFileSync(path.join(__dirname, src), { encoding: 'utf-8' });
-
-const compile = (src) =>
-    hbs.compile(readLocal(src), { noEscape: true });
-
-const partial = (name, source) =>
-    hbs.registerPartial(name, readLocal(source));
-
-const safeString = (str) =>
-    new hbs.SafeString(str);
-
-partial('code_block', 'code-block.hbs');
-partial('property', 'property.hbs');
-
-module.exports = {
-    compile: hbs.compile,
-    compileFrom: compile,
-    partialFrom: partial,
-    safeString: safeString
-};
-

package/src/api/type-links.json

@@ -1,3 +0,0 @@
-{
-    "EventEmitter": "{{ site.data.urls.angular['eventemitter'] }}"
-}

package/src/api/type-utils.js

@@ -1,179 +0,0 @@
-"use strict";
-
-const comment = require('./comment');
-
-const unionTypes = (member) =>
-    member.type.types.map(type => {
-        switch (type.type) {
-        case 'literal':
-            return `"${type.value}"`;
-        default:
-            return typeString({ type });
-        }
-    });
-
-const paramName = (param) => {
-    let name = param.name;
-    if (name === '__namedParameters') {
-        name = '_';
-    }
-
-    return name + ((param.flags || {}).isOptional ? "?" : "");
-};
-
-const anonParams = (definition) => {
-    let params = [];
-    if (definition.parameters) {
-        params = definition.parameters.map((param) => ({
-            _ref: param,
-            name: paramName(param),
-            type: typeString(param)
-        }));
-    }
-
-    return params;
-};
-
-const params = (definition, parentName) => {
-    const paramComment = (param) =>
-        comment(param, parentName, 'parameter').trim();
-
-    const params = anonParams(definition);
-    params.forEach((param) => {
-        param.comment = paramComment(param._ref);
-    });
-
-    return params;
-};
-
-const signature = (definition) => {
-    const args = anonParams(definition).map((param) =>
-        `${param.name}: ${param.type}`
-    );
-
-    const returnType = typeString(definition);
-
-    return {
-        params: args,
-        returnType: returnType
-    };
-};
-
-const sigParams = sig => `${sig.params.join(', ')}`;
-
-const indexType = (definition) => {
-    const sig = signature(definition);
-    return `{[${sigParams(sig)}]: ${sig.returnType}}`;
-};
-
-const callSignature = (definition) => {
-    const sig = signature(definition);
-    return `(${sigParams(sig)})`;
-};
-
-const callType = (definition) => {
-    const sig = signature(definition);
-    return `(${sigParams(sig)}) => ${sig.returnType}`;
-};
-
-const typeName = (type) => {
-    const name = type.name;
-    if (type.typeSlug) {
-        return `[${ name }]({% slug ${ type.typeSlug } %})`;
-    } else if (type.typeLink) {
-        return `[${ name }](${ type.typeLink })`;
-    } else if (type.type === 'array') {
-        return typeName(type.elementType);
-    }
-    return name;
-};
-
-const INTERSECTION = ' [intersected](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types) with ';
-const singleTypeString = (type) => {
-    let suffix = '';
-
-    if (type.type === 'literal') {
-        return type.value;
-    }
-
-    if (type.type === 'intersection') {
-        return unionTypes({ type }).join(INTERSECTION);
-    }
-
-    if (type.type === 'reflection') {
-        const decl = type.declaration;
-        if (decl.signatures) {
-            const sig = decl.signatures[0];
-            if (decl.name === '__type' && sig.kindString === 'Call signature') {
-                return callType(sig);
-            }
-        } else if (decl.indexSignature) {
-            return indexType(decl.indexSignature[0] || decl.indexSignature);
-        } else if (decl.children) {
-            // Anonymous interface like
-            // export type Foo = boolean | { bar: boolean };
-            const children = decl.children.map(child =>
-                `${paramName(child)}: ${typeString(child)};`);
-
-            return `{ ${children.join(' ')} }`;
-        }
-    }
-
-    if (type.type === 'array') {
-        return `${singleTypeString(type.elementType)}[]`;
-    }
-
-    if (type.type === 'tuple') {
-        return `[${type.elements.map(singleTypeString).join(', ')}]`;
-    }
-
-    if (type.typeArguments) {
-        suffix = `<${singleTypeString(type.typeArguments[0])}>`;
-    }
-
-    const name = typeName(type);
-
-    return name + suffix;
-};
-
-const typeString = (prop) => {
-    const type = prop.type;
-
-    if (!type && prop.kindString === 'Method') {
-        return singleTypeString(prop.signatures[0]);
-    }
-
-    if (type.type === 'union') {
-        return unionTypes(prop).join(' | ');
-    }
-
-    if (type.type === 'literal') {
-        return `"${type.value}"`;
-    }
-
-    return singleTypeString(prop.type);
-};
-
-const fullName = (member) => {
-    let suffix = '';
-
-    const typeParam = member.typeParameter;
-    if (typeParam) {
-        suffix = '<' +
-            typeParam.map(t => t.name).join(', ') +
-        '>';
-    }
-
-    return member.name + suffix;
-};
-
-module.exports = {
-    callSignature: callSignature,
-    callType: callType,
-    fullName: fullName,
-    params: params,
-    unionTypes: unionTypes,
-    typeString: typeString,
-    singleTypeString: singleTypeString
-};
-

package/src/api/union-page.hbs

@@ -1,14 +0,0 @@
-{{> member_meta}}
-
-# {{name}}
-{{comment}}
-
-`type` {{name}} =
-  {{~#each types~}}
-    {{~#contains this 'slug'}} {{this}}
-      {{~else equals this '"null"'}} `null`
-      {{~else contains this '"'}} {{this}}
-      {{~else}} `{{this}}`
-    {{~/contains~}}
-    {{~#unless @last}} |{{/unless~}}
-  {{~/each}};

package/src/api/union-page.js

@@ -1,17 +0,0 @@
-"use strict";
-
-const template = require('./template-utils.js');
-const comment = require('./comment.js');
-const typeUtils = require('./type-utils.js');
-
-const unionTemplate = template.compileFrom('union-page.hbs');
-const unionPage = (member, meta) =>
-    unionTemplate(Object.assign({}, meta, {
-        comment: comment(member),
-        name: member.name,
-        types: typeUtils.unionTypes(member),
-        slug: member.slug
-    }));
-
-module.exports = unionPage;
-

package/src/api/utils.js

@@ -1,40 +0,0 @@
-/*eslint no-console: 0 */
-"use strict";
-
-const flatten = (arr) => arr.reduce((flat, next) => flat.concat(next), []);
-
-const nameComparer = (a, b) => a.name.localeCompare(b.name);
-
-const not = predicate => member => !predicate(member);
-
-const ignore = predicate => props => (props || []).filter(predicate);
-
-const hasProp = prop => obj => Boolean(obj[prop]);
-
-const groupBy = (predicate, list) =>
-    list.reduce((acc, item) => {
-        const field = predicate(item);
-        acc[field] = acc[field] || [];
-        acc[field].push(item);
-        return acc;
-    }, {});
-
-const WARNINGS = [];
-const warn = (type, text) => {
-    const msg = `WARN ${type} ${text}`;
-    WARNINGS.push(msg);
-
-    console.warn(msg);
-};
-
-module.exports = {
-    groupBy: groupBy,
-    flatten: flatten,
-    nameComparer: nameComparer,
-    warn: warn,
-    warnings: () => WARNINGS,
-    not: not,
-    ignore: ignore,
-    hasProp: hasProp
-};
-

package/src/api/warn.js

@@ -1,22 +0,0 @@
-"use strict";
-
-const utils = require('./utils.js');
-const rules = require('./warning-rules.js');
-
-const runner = rules => member =>
-    rules.reduce((result, rule) => result && rule(member), true);
-
-const warn = (member, parentName, kind = 'member') => {
-    const shouldWarn = runner(rules);
-    let source = member.name;
-
-    if (parentName) {
-        source = `${parentName}.${source}`;
-    }
-
-    if (shouldWarn(member)) {
-        utils.warn(`Undocumented ${kind}`, source);
-    }
-};
-
-module.exports = warn;

package/src/api/warning-rules.js

@@ -1,14 +0,0 @@
-"use strict";
-
-const utils = require('./utils.js');
-const isField = require('./is-field.js');
-
-const namedParams = member => member.name !== '__namedParameters';
-
-const rules = [
-    namedParams,
-    utils.not(isField)
-];
-
-module.exports = rules;
-