10 examples of 'ng generate module with component' in JavaScript

166
function createComponentModule({ packageMeta, packageExportNames }) {
167
  const packageName = packageMeta.name;
168
  const moduleExports = packageExportNames.join(", ");
169
  const dest = createComponentModuleDestPath(packageName, "es.js");
170
  const data = `export { ${moduleExports} } from "${packageName}";\n`;
171
172
  return writeFile(dest, data);
173
}

74
private static generateComponent(template:string, url:string, context:any) {
75
    var contextString = "";
76
    for (var key in context) {
77
        //noinspection JSUnfilteredForInLoop
78
        contextString += `#${key}="${key}" `;
79
    }
80
81
    @Component({
82
        selector: 'sui-template-generated',
83
        template: `${template}`,
84
        directives: [TemplateDirective],
85
        styles: [':host { display: none }']
86
    })
87
    class GeneratedTemplateComponent { }
88
    return GeneratedTemplateComponent;
89
}

79
addModuleAsComponent() {
80
    this._components.set(this._metatype.name, {
81
        name: this._metatype.name,
82
        metatype: this._metatype,
83
        isResolved: false,
84
        instance: null,
85
    });
86
}

1
function module() {
2
  {
3
    // Output CSS before any HTML that might be styled.
4
    IMPORTS___.emitCss___(['.', ' p {\n  color: purple\n}\n.',
5
                           ' p {\n  color: pink\n}']
6
                           .join(IMPORTS___.getIdClass___()));
7
    // Set up local variables required for HTML support.
8
    // Attach the onclick handler.
9
    var el___;
10
    var emitter___ = IMPORTS___.htmlEmitter___;
11
    el___ = emitter___.byId('id_4___');
12
    // Remove the bits the first script shouldn't see.
13
    emitter___.attach('id_4___');
14
    // Define handlers as needed.
15
    var c_3___ = ___.markConstFunc(function (event, thisNode___) {
16
      wasClicked(thisNode___);
17
    });
18
    el___.onclick = function (event) {
19
      return ___.plugin_dispatchEvent___(this, event, ___.getId(IMPORTS___), c_3___, 2);
20
    };
21
    // Remove the manufactured ID
22
    emitter___.rmAttr(el___, 'id');
23
  }
24
}

1
export default function init(ngModule) {
2
  ngModule.component('queryLink', {
3
    bindings: {
4
      query: '<',
5
      visualization: '<',
6
      readonly: '<',
7
    },
8
    template: `
9
      <a>
10
        
11
        <span>{{$ctrl.query.name}}</span>
12
      </a>
13
    `,
14
    controller() {
15
      this.getUrl = () =&gt; {
16
        let hash = null;
17
        if (this.visualization) {
18
          if (this.visualization.type === 'TABLE') {
19
            // link to hard-coded table tab instead of the (hidden) visualization tab
20
            hash = 'table';
21
          } else {
22
            hash = this.visualization.id;
23
          }
24
        }
25
26
        return this.query.getUrl(false, hash);
27
      };
28
    },
29
  });
30
}

53
private buildComponent(): void {
54
    if (!this.componentType) {
55
        return;
56
    }
57
    try {
58
        this.destroyComponent();
59
        // this.entry.clear();
60
        const componentFactory = this.componentFactoryResolver.resolveComponentFactory>(this.componentType);
61
        const component = this.entry.createComponent(componentFactory, 0);
62
        this.initComponent(component);
63
        this.component = component;
64
    } catch (e) {
65
        console.error('load component error.');
66
        console.error(e);
67
    }
68
}

47
function generateModule(moduleName, base, nComponents) {
48
  let ts = `// Code generated by angular-stress-test
49
50
import { NgModule } from '@angular/core';
51
import { CommonModule } from '@angular/common';
52
53
`;
54
  for (let i = 1; i <= nComponents; i++) {
55
    ts += `import { ${componentName(base + i)} } from './${componentfileName(base + i)}';\n`;
56
  }
57
  ts += `
58
59
@NgModule({
60
  declarations: [`;
61
62
  for (let i = 1; i <= nComponents; i++) {
63
    ts += `\n    ${componentName(base + i)},`;
64
  }
65
  ts += `
66
  ],
67
  imports: [CommonModule],
68
  exports: [`;
69
  ts += `\n    ${componentName(base + 1)},`;
70
  exportedComponentForModule[moduleName] = base + 1;
71
  ts += `
72
  ]
73
})
74
export class ${moduleName} { }
75
`;
76
77
  mkdirp.sync(`${baseDir}${moduleName}`);
78
  const moduleFileName = `${baseDir}${moduleName}/${moduleName}.module`;
79
  fs.writeFileSync(moduleFileName + '.ts', ts);
80
}

25
public CreateComponent(tmpl: string, injectDirectives: any[]): any {
26
27
    @Component({
28
        selector: 'dynamic-component',
29
        template: tmpl
30
    }) //directives: injectDirectives,
31
    class CustomDynamicComponent implements IHaveDynamicData {
32
33
        public name: string;
34
        public entity: { description: string };
35
    }
36
    ;
37
38
    return CustomDynamicComponent;
39
}

11
function componentBuilder(template) {
12
    @Component({
13
        selector: 'my-component',
14
        template
15
    })
16
    class CustomComponent {
17
    }
18
19
    return CustomComponent;
20
}

8
function genModule(config, moduleID) {
9
  if (!config) {
10
    return null;
11
  }
12
13
  var _config = babelHelpers.slicedToArray(config, 5),
14
      moduleName = _config[0],
15
      constants = _config[1],
16
      methods = _config[2],
17
      promiseMethods = _config[3],
18
      syncMethods = _config[4];
19
20
  invariant(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'), 'Module name prefixes should\'ve been stripped by the native side ' + 'but wasn\'t for ' + moduleName);
21
22
  if (!constants && !methods) {
23
    return {
24
      name: moduleName
25
    };
26
  }
27
28
  var module = {};
29
  methods && methods.forEach(function (methodName, methodID) {
30
    var isPromise = promiseMethods && arrayContains(promiseMethods, methodID);
31
    var isSync = syncMethods && arrayContains(syncMethods, methodID);
32
    invariant(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
33
    var methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
34
    module[methodName] = genMethod(moduleID, methodID, methodType);
35
  });
36
  babelHelpers.extends(module, constants);
37
38
  if (__DEV__) {
39
    BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
40
  }
41
42
  return {
43
    name: moduleName,
44
    module: module
45
  };
46
}