lang
stringclasses 10
values | seed
stringlengths 5
2.12k
|
|---|---|
typescript | }
}
)
public render() {
const { Component, pageProps } = this.props
return <Component {...pageProps} />
}
}
|
typescript | import type { RegisterOptions as TSNodeRegisterOptions } from "ts-node";
import type { ITSConfigFn, PublicOpts, IGatsbyPluginDef } from "./public";
export type PropertyBag = Record<string, any>;
export type ValidExts = ".js" | ".ts" | ".jsx" | ".tsx";
export type RegisterType = "ts-node" | "babel";
export type GatsbyConfigTypes = "config" | "node" | "browser" | "ssr"
export type ConfigTypes = GatsbyConfigTypes | "plugin";
export type EndpointResolutionSpec = GatsbyConfigTypes | {
type: GatsbyConfigTypes; |
typescript | }
export class ArtificialPlayer extends PlayerBase {
private currentBoard: Chess.Board;
private engineWorker: Worker;
private playedMove: Chess.GameMove;
constructor(colour: Chess.Player) {
super(colour);
this.engineWorker = undefined; |
typescript | import Link from 'next/link';
import LogoSVG from './LogoSVG';
import { Wrapper } from './styles';
const Logo = () => (
<Wrapper> |
typescript | const getLinkLocaleSlug = useGetLinkLocaleSlug();
const localeSlug = getLinkLocaleSlug();
const action = localeSlug ? `/${localeSlug}/${SEARCH_PAGE_URL}` : `/${SEARCH_PAGE_URL}`;
return (
<form className={styles.container} method="GET" action={action}>
<div className={styles.inputWrapper}>
<FormInput
label={formatMessage(translations.search.inputLabel)}
type="search" |
typescript | })
break;
}
return schema;
}
}
return {}
} |
typescript | },
{
name: "Текст рассылки",
type: CommandArgTypes.Text
}
] as const);
function broadcastHandler(msg: Message, args: readonly [string, number, string, string, string]) {
console.log(args);
return args[4];
}
|
typescript | // Dump all tables including schema but exclude the rows of data_values
shell.exec(`mysqldump ${settings.DB_NAME} --ignore-table=${settings.DB_NAME}.django_session --ignore-table=${settings.DB_NAME}.user_invitations --ignore-table=${settings.DB_NAME}.data_values -r /tmp/owid_metadata.sql`)
shell.exec(`mysqldump --no-data ${settings.DB_NAME} django_session user_invitations data_values >> /tmp/owid_metadata.sql`)
// Strip passwords
shell.exec(`sed -i -e "s/bcrypt[^']*//g" /tmp/owid_metadata.sql`)
// Add default admin user
await fs.appendFile("/tmp/owid_metadata.sql", "INSERT INTO users (`password`, `isSuperuser`, `email`, `fullName`, `createdAt`, `updatedAt`, `isActive`) VALUES ('<PASSWORD>$12$EXfM7cWsjlNchpinv.j6KuOwK92hihg5r3fNssty8tLCUpOubST9u', 1, '<EMAIL>', 'Admin User', '2016-01-01 00:00:00', '2016-01-01 00:00:00', 1);\n")
await db.end()
}
dataExport() |
typescript | import { Contribution } from "@phylopic/source-models"
export type WorkingSubmission = Partial<Omit<Contribution, "contributor" | "created" | "uuid">>
|
typescript | import { getSourceFiles } from 'ng-morph/source-file';
import { arrayFlat, getDeclarationGetter } from 'ng-morph/utils';
import { VariableStatement } from 'ts-morph';
export const getVariables = getDeclarationGetter<VariableStatement>((pattern) =>
arrayFlat(getSourceFiles(pattern).map((file) => file.getVariableStatements()))
); |
typescript | import 'rxjs/add/operator/take';
@Injectable()
export class AuthGuard implements CanActivate {
constructor(private _loginServ: LoginService,
private router: Router) {}
canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
return this._loginServ.af.auth.map((auth) => {
if (!auth) {
this.router.navigateByUrl('/');
return false;
}
return true; |
typescript | export interface RouteEvent {
event: string,
'content-name': string,
'content-view-name': string,
[key: string]: any |
typescript | return has(obj, path);
}
/**
* 检查一个object的某个属性是否为空 |
typescript | @action.bound addBarcode(): this {
this.barcodes.push(new Barcode());
return this;
}
removeBarcode(barcode: Barcode): this {
this.barcodes = this.barcodes.filter(b => b !== barcode); |
typescript | import Workspace_ from './workspace';
export declare namespace WorkSpaces {
const Workspace: typeof Workspace_;
type Workspace = Workspace_;
}
|
typescript | import { IFluentIconsProps } from '../IFluentIconsProps.types';
const Add12Regular = (iconProps: IFluentIconsProps, props: React.HTMLAttributes<HTMLElement>): JSX.Element => {
const {
primaryFill,
className
} = iconProps; |
typescript | expect(rooms.length).be.equal(1);
});
});
describe('with alias', async () => {
it('ok', async () => {
await getRepository(User).save(user);
// create pending
await redisAsync().setAsync(
'pending:room:room1',
JSON.stringify({ room_alias_name: 'alias1' })
);
// create alias in redis |
typescript | export const componizerCommandName = 'extension.componize';
export const defaultComponentName = 'NewComponent';
export const defaultSkipImport = 'false';
|
typescript | async getPostData(){
const postData = await this.postrepo.find();
return postData;
}
async postPostData(post){
const newPost = await new this.postrepo(post);
const save = await newPost.save();
return save;
}
async deletePosttData(id){ |
typescript | export interface ProjectLanguagesProps {
projectLanguages: any;
}
|
typescript | export function checkTaskIsNow(taskDate) {
return taskDate > Date.now() ? false : true
}
|
typescript | return apiClient({
url: `/saker/søk`,
method: 'POST',
body: {
fnr: fnr,
},
});
}
export async function fetchSakBySaksnummer(saksnummer: string): Promise<ApiClientResult<Sak>> {
return apiClient({
url: `/saker/søk`,
method: 'POST',
body: { |
typescript |
const Cloud20Filled = (iconProps: IFluentIconsProps, props: React.HTMLAttributes<HTMLElement>): JSX.Element => {
const {
primaryFill,
className
} = iconProps; |
typescript | let productService: ProductService;
beforeEach(() => {
TestBed.configureTestingModule({
providers: [
{
provide: RoutingConfig,
useValue: {
routing: {
routes: {
product: {
paths: ['product/:productCode/:name'],
},
},
}, |
typescript | @NgModule({
declarations: [
AppComponent,
HeaderDesktopComponent,
HeaderMobileComponent,
StageComponent, |
typescript | import { invert } from "./invert";
describe("invert", () => {
it("should return undefined if the inverted value is undefined", () => {
const scale = new BandScale();
// @ts-ignore: Disabled for testing purposes
spyOn(scale, "invert").and.returnValue(undefined);
const inverted = invert(scale, 0);
expect(inverted).toBeUndefined();
});
|
typescript | permanentLabels,
setPermanentLabels,
REALTIME_RANGE,
isVehicleRealTime,
map,
setMap,
realtimeVehiclesPosition,
setRealtimeVehiclesPosition,
filterVehicles,
setFilterVehicles,
vehicleDetails,
setVehicleDetails
} |
typescript | const renderOnServer = () =>
renderToString(
<Listbox>
<Item key="earth">Earth</Item>
<Item key="jupiter">Jupiter</Item>
<Item key="mars">Mars</Item>
</Listbox>
);
expect(renderOnServer).not.toThrow();
});
|
typescript | const useStyles = makeStyles(() => ({ table: { flex: 1 } }));
const DeletedUsersTable: React.FC = () => {
const classes = useStyles();
const { locale } = useLocale();
const { users, loading } = useAllDeletedUsers();
const columns: Column<typeof users[number]>[] = useMemo(
() => [
{
Header: locale('users:form:name'),
accessor: 'name', |
typescript | }
@Component({
selector: 'wallet-add-key-tunnel',
templateUrl: './wallet-add-key.component.html',
styleUrls: ['./wallet-add-key.component.scss'],
changeDetection: ChangeDetectionStrategy.OnPush
})
export class WalletAddKeyTunnelComponent implements OnInit {
steps = steps;
step = this.steps.password;
key: Key;
encrypting$: Observable<boolean>; |
typescript | }
export async function compileSass(options: SassOptions, cwd?: string): Promise<SassResult> {
const { input, output, compress, sourceMap } = options;
const args = ['sass', input, output]; |
typescript | type: SET_DRAWER_STATUS,
payload: !drawerStatus
};
}
export function setDrawer() {
return async (dispatch: Dispatch, getState: GetState) => {
const { drawer } = getState();
dispatch(changeState(drawer)); |
typescript | routes: Record<string, FC>;
onChange(previous: any, current: any, changed: ChangeSet): void;
}
export interface DebugCustomBooleanSetting {
value: boolean;
type: 'boolean';
onChange(newValue: boolean, prevValue: boolean): void;
} |
typescript | .map(item => ({
...item.product,
quantity: item.quantity,
itemId: item.id
}));
}
return [];
}
@Expose()
get total() {
if (this.items) {
return this.items.filter(item => !!item)
.reduce((total, item) => { |
typescript | queries: queriesType
): Promise<Record<string, unknown>> {
const url = generateRequestURL(queries);
const json = (await (await fetch(url)).json()) as response;
// API's response isn't returned in its entirety by this function. |
typescript | toString: () => `var(${name})`,
};
}
/**
* Recursive function that will walk down the token object
* and perform the setupToken function on each token.
* Similar to what Style Dictionary does.
*/
function setupTokens(obj: any, path = []) { |
typescript | import { ContextMenuExample, MenuBarExample } from 'examples';
import { CodeViewer } from 'components';
import { Checkbox, Divider } from 'antd';
import axuiLogo from 'assets/axui-logo.png';
const GitHubButton = require('react-github-button');
const Component = styled.div`
.app-header {
background: #333;
color: #fff; |
typescript |
import omegaup_Markdown from './Markdown.vue';
describe('Markdown.vue', () => {
it('Should render markdown contents', () => {
const wrapper = shallowMount(omegaup_Markdown, {
propsData: {
markdown: '_Hello_, **World**!',
},
});
expect(wrapper.html()).toEqual(
expect.stringContaining('<p><em>Hello</em>, <strong>World</strong>!</p>'),
);
}); |
typescript | MAP_KEY = 'MAP_KEY',
MAP_VALUE = 'MAP_VALUE',
PLAIN = 'PLAIN',
QUOTE_DOUBLE = 'QUOTE_DOUBLE',
QUOTE_SINGLE = 'QUOTE_SINGLE',
SEQ = 'SEQ',
SEQ_ITEM = 'SEQ_ITEM'
|
typescript | expect(binaryToHex(defaultBinaryPhash)).toEqual(defaultHexPhash)
})
it('should convert to bin', (): void => {
expect(hexToBinary(defaultHexPhash)).toEqual(defaultBinaryPhash)
})
it('should fail properly on convert to bin', (): void => {
expect.assertions(1)
try {
hexToBinary(defaultHexPhash + 'z') |
typescript | export * from './getIcon'; |
typescript | include: [User],
where: { '$user.id$': userId },
});
if (tokenData) {
tokenData.refreshToken = refreshToken;
return tokenData.save();
}
const user = await this.usersService.findOneById(userId); |
typescript | }
enableMfa(value: boolean, idToken: string): Observable<any> {
const apiUrl = this.storeService.get('mfa','api_url');
const path = `mfaEnabled`;
const url = `${apiUrl}${path}`;
const body = `value=${value}`; |
typescript | import { connection } from '../connect';
export async function publish(queue: string, msg: any) {
const channel = await connection.createChannel();
await channel.assertExchange(queue, 'fanout');
await channel.assertQueue(queue, { durable: true });
await channel.bindQueue(queue, queue, '');
const headers = { 'x-original-queue': queue, 'x-retries': 0 };
const stringified = typeof msg === 'string' ? msg : JSON.stringify(msg);
channel.publish(queue, queue, Buffer.from(stringified), { headers, persistent: true });
channel.close(); |
typescript | imports: [
CommonModule,
MaterialSharedModule,
SharedModule
],
exports: [
ModalPlanetComponent
],
entryComponents: [
ModalPlanetComponent |
typescript | <List
className="user-list"
loading={loading}
itemLayout="horizontal"
dataSource={useList}
renderItem={ (item,index) => ( |
typescript | onError: (e: unknown) => E,
): ReaderEither<S, E, A> => {
try {
return R.of(E.right(f()));
} catch (e) {
return R.of(E.left(onError(e)));
}
};
export const fromEither = <S, E, A>(
ta: E.Either<E, A>,
): ReaderEither<S, E, A> => R.of(ta);
|
typescript | import { MatSnackBar } from '@angular/material/snack-bar';
@Injectable({
providedIn: 'root',
})
export class SnackbarService {
constructor(public snackBar: MatSnackBar) { }
openSnackBar(message: string, action: string) { |
typescript | } else if (!ref.current.contains(target)) {
callback(event);
}
}
};
window.addEventListener('mousedown', listener);
document.addEventListener(`touchstart`, listener);
return () => {
window.removeEventListener('mousedown', listener);
document.removeEventListener(`touchstart`, listener);
};
}, [callback, ref, children]); |
typescript | let shallow: any;
let wrapper:ShallowWrapper;
beforeEach(() => {
shallow = createShallow({ dive: true });
wrapper = shallow(<MenuHeaderColumn />);
});
it("should render correctly", () => { |
typescript |
const options = Object.assign(defaults, customProps);
return new DateRange(options);
}
let d1: DateRange;
let d2: DateRange;
beforeEach(() => {
d1 = buildDateRange();
d2 = buildDateRange();
});
it('should pass when objects are identical', () => {
expect(d1).toEqualDateRange(d2); |
typescript |
const todos :Reducer<Todo[], any> = (state: Todo[] = [],action) => {
switch(action.type){
case 'ADD_TODO' :
return [...state,
{ |
typescript | horizontalAlign: 'left'
},
xaxis: {
type: 'datetime'
},
},
};
return (
<Chart
options={area.options}
series={area.series}
type="area"
width={width}
/> |
typescript | sortSchema: boolean;
}
export interface SecurityConfig {
key: string | undefined;
expiresIn: string;
refreshIn: string;
aud: string;
iss: string;
nonceName: string;
nonceExpiresIn: number;
nonceEncryptAlg: string;
nonceEncryptKey: string | undefined; |
typescript | this.totalBoxes = this._parcelInfo[index].number_of_detected_boxes;
this.transparentBoxes = this._parcelInfo[index].number_of_transparent_boxes;
this.cardboardBoxes = this._parcelInfo[index].number_of_cardboard_boxes;
}
emitDetectedBoxes() {
let detectedBoxes: DetectedBoxModel = {totalBoxCount: this.totalBoxes, transparentBoxCount: this.transparentBoxes, cardboardBoxCount: this.cardboardBoxes};
this.detectedBoxes.emit(detectedBoxes);
} |
typescript | info2={info2}
url={url}
repo={repo}
img={img}
id={id}
/>
);
})}
</div>
</div>
</Container>
</section>
);
};
|
typescript | @Pipe({ name: 'myObjectKeys' })
export class KeysPipe implements PipeTransform {
public transform(value, args: string[]): any[] {
if (!(typeof value === 'object')) {
return [];
}
return Object.keys(value);
}; |
typescript | onmessage = function (): void {
postMessage(self.location.href);
close();
};
|
typescript | query GetPostByUserNameAndTitle($userName: String!, $title: String!) {
getPostByUserNameAndTitle(userName: $userName, title: $title) {
id
title
prettyTitle
userName
userLocale |
typescript | {
flatErrors[
'preferredSolution.security.isBeingReviewed'
]
} |
typescript | const { token_type, access_token, refresh_token, expires_in } = await api.post('auth/token', { json }).json()
const token = {
type: token_type,
access: access_token,
refresh: refresh_token,
expires: Date.now() + expires_in * 1000
}
storage.set('token', token)
}
export const logout = async (): Promise<void> => {
const { refresh } = storage.get('token')
await api.delete('auth/token', { json: { token: refresh } })
storage.remove('token') |
typescript | export enum CustomerChangeType {
CustomerBindingStarted = 'CustomerBindingStarted',
CustomerBindingStatusChanged = 'CustomerBindingStatusChanged',
CustomerBindingInteractionRequested = 'CustomerBindingInteractionRequested'
}
|
typescript | _ready() {
this.g_texture_width = this.texture.get_size().x * this.scale.x
}
_process(delta): void {
this.position = new godot.Vector2(this.position.x + this.velocity, 160)
this.g_reposition()
}
g_reposition(): void {
if(this.position.x < -this.g_texture_width) {
|
typescript | export * from './navigation-tree/navigation-tree.component';
export * from './navigation-menu/navigation-menu.component';
export * from './search/search.component';
export * from './versioning/versioning.component';
export * from './edit-button/edit-button.component';
export * from './snack-bar-copy/snack-bar-copy.component';
|
typescript | expect(assemblyProgram.directives.length).toBe(1);
expect(assemblyProgram.directives[0]).toBeInstanceOf(DataDirective);
expect(assemblyProgram.directives[0].toString()).toBe(`data @foo 0x00`);
assemblyProgram = AssemblyProgram.parse(`data @foo 0x0 0x1 0x2`);
expect(assemblyProgram.directives.length).toBe(1);
expect(assemblyProgram.directives[0]).toBeInstanceOf(DataDirective);
expect(assemblyProgram.directives[0].toString()).toBe(`data @foo 0x00 0x01 0x02`);
assemblyProgram = AssemblyProgram.parse(`data @foo 'This is a string!\\n'`);
expect(assemblyProgram.directives.length).toBe(1);
expect(assemblyProgram.directives[0]).toBeInstanceOf(DataDirective); |
typescript | config
);
dispatch(updateUserAdmin(data));
} catch (err) {
dispatch(actionFail(err));
} |
typescript |
export interface IDummyUnitManager {
GetDummy(): Unit;
RecycleDummy(unit: Unit): boolean;
} |
typescript | }
componentDidMount() {
const config: Phaser.Types.Core.GameConfig = {
type: Phaser.AUTO,
width: GAME_WIDTH,
height: HEIGHT,
parent: 'game', |
typescript | const i18nNoDataAvailable = 'No data available';
const i18nSince = 'Since ';
const i18nTotalErrors = 'Total Errors';
const i18nTotalMessages = 'Total Messages';
const i18nUptime = 'Uptime';
const lastProcessed = '2 May 2019 08:19:42 GMT';
const messages = 26126;
const start = 2323342333;
const propsOnlyRequired = {
i18nLastProcessed,
i18nNoDataAvailable,
i18nSince, |
typescript | <div className="flex flex-column gap-xs" style={{ backgroundColor: "white", padding: "8px", maxWidth: "380px" }}>
<Input placeholder="ex: <NAME>" inputSize="lg" />
<Input placeholder="ex: <NAME>" />
<Input placeholder="Search" before={<Icon color="surface" src={SearchIC} />} />
<Input placeholder="Search" after={<Icon color="surface" src={SearchIC} />} />
<Input placeholder="john" before={<Text variant="b2">@</Text>} after={<Text variant="b2">:matrix.org</Text>} />
<Input placeholder="ex: <NAME>" inputSize="sm" />
<Input placeholder="ex: <NAME>" state="success" />
<Input placeholder="ex: <NAME>" state="error" />
<Input placeholder="ex: <NAME>" disabled />
<Input placeholder="ex: <NAME>" state="success" disabled />
<Input placeholder="ex: <NAME>" state="error" disabled />
</div> |
typescript | ],
declarations: [
FooterComponent,
NavbarComponent,
SidebarComponent,
ScrollTopComponent,
BreadcrumbComponent
],
exports: [
FooterComponent,
NavbarComponent,
SidebarComponent, |
typescript | && selectedBuildingName !== RECOMMENDED && (
<Box className={classes.errBox}>
<Text content="Something went wrong." color="red" />
<Button
content="Try again"
text
onClick={() => {
refreshWorkSpace();
logEvent(USER_INTERACTION, [
{ name: UI_SECTION, value: UISections.WorkspaceHome },
{ name: DESCRIPTION, value: "refreshWorkSpace" }, |
typescript | export interface Formatter {
accept(object: any): boolean;
preview(object: any): any;
hasChildren(object: any): boolean;
children(object: any): { name: string; value: any }[];
}
|
typescript | onCreate?: (editor: EditorType) => void
onDestory?: () => void
value?: string
}
|
typescript | * An opaque value that represents the internal version of this object that can be used by
* clients to determine when objects have changed. May be used for optimistic concurrency, change
* detection, and the watch operation on a resource or set of resources. Clients must treat these
* values as opaque and passed unmodified back to the server. They may only be valid for a
* particular resource or set of resources. Populated by the system. Value must be treated as
* opaque by clients.
*
* More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
*/
readonly resourceVersion?: string;
/**
* SelfLink is a URL representing this object. Populated by the system. |
typescript | TermsConditionsService
]
})
export class ApiServicesModule {}
|
typescript |
this._onChange.dispatch(data);
}
public async load(): Promise<T | null> {
logger.debug("Reading data");
return this.data;
}
|
typescript |
export class DecoratorHasBeenAppliedError extends RuntimeError {
constructor(decorator: DecoratorFactory, className: string, propertyName: string | symbol) {
super(`Decorator @${decorator.name}() has already been applied to ${className}${propertyName ? `.${String(propertyName)}` : ''}`);
}
}
|
typescript | }
return config;
}
/**
* Our own session creation to keep track of how the session is doing.
* In here we add the Hook that will inform us from Stripe when session is completed.
* @param course: We want the courseId (which is the product) and the user to be added to the data
*/
export async function createPurchaseSessionData(course: IRequestInfo) {
const purchaseSession = await db.collection(FirebaseCollectionType.PurchaseSession).doc();
|
typescript | <gh_stars>1-10
export const DEFAULT_SPACING = 20;
export const DEFAULT_RADIUS = 4;
|
typescript | }
return this._compareFunc(this._store[indexA]!, this._store[indexB]!);
}
/**
* Swaps the items at the specified indices
* @param indexA - Index of an item to swap
* @param indexB - Index of an item to swap
*/
private swap(indexA: number, indexB: number): void
{
if (!this.isValidIndex(indexA) ||
!this.isValidIndex(indexB)) |
typescript | import { useContext } from 'react';
import Context from './Context';
export default function useKitchenWorkerContext() {
const ctx = useContext(Context);
return ctx;
}
|
typescript | stdoutResult = []
jest
.spyOn(process.stdout, 'write')
.mockImplementation(val => stdoutResult.push(require('strip-ansi')(val.toString())))
})
afterEach(() => jest.restoreAllMocks())
|
typescript | // DIRECTIVES
export * from './directives/proxies';
// PACKAGE MODULE
export { ComponentLibraryModule } from './component-library-module';
|
typescript |
export const Visualization = () => {
const width = useAppSelector(exportSelectors.selectWidth);
const height = useAppSelector(exportSelectors.selectHeight);
const exporting = useAppSelector(exportSelectors.selectExporting);
return (
<div className={classnames(['c-tool-visualization', `${exporting ? 'exporting' : ''}`])}>
{exporting && <div className="exporting-message">Exporting...</div>}
<div
className="m-auto d-flex flex-column js-visualization"
// We need both width and min-width: |
typescript | }
export type QueryGetAdgerdirPageArgs = {
input: GetAdgerdirPageInput
}
export type QueryGetOrganizationArgs = {
input: GetOrganizationInput |
typescript |
if (this.kcProject?.knowledgeSource) {
ksList = [...ksList, ...this.kcProject.knowledgeSource];
const subTrees = this.projectService.getSubTree(this.kcProject.id.value);
for (let subTree of subTrees) {
// Ignore current project...
if (subTree.id === this.kcProject.id.value) {
continue;
} |
typescript | $(select).append(noOptionsOption);
noOptionsOption.attr('selected','selected');
return;
}else{
$(select).removeClass('disabled'); |
typescript | </NavLink>
</li>
<li>
<NavLink to="/contact" className={styles.menu__link}>
contact
</NavLink>
</li>
</ul> |
typescript | export type { TypographyProps } from './Typography';
export { Typography, Typography as default } from './Typography';
|
typescript | import { useTranslation } from 'react-i18next';
import { ACTIVE_TRANSLATION } from '@constants';
const useTranslate = (text = '') => {
const { t } = useTranslation();
return React.useMemo(() => {
if (ACTIVE_TRANSLATION) {
return t(text);
}
return text; |
typescript | weight={weightService.getWeight(ALL_COMPONENTS, node.key)}
scoped={true}
node={node}
onSelect={node => {
history.push(`/${componentName}/node/${node}`);
}}
/>
);
})}
</div>
</div>
</div> |
typescript | }
},
});
interface DialogTitleProps extends WithStyles<typeof styles> {
text: string
}
export const NeonText1 = withStyles(styles)((props: DialogTitleProps) => {
const {text, classes, ...other} = props;
return (
<h1 className={classes.neonText}>
{text} |
typescript | <CacheProvider value={cache}>
<StylesProvider jss={jss}>
<Jupyter collaborative={true} terminals={true}>
<Header/>
<Gallery/>
</Jupyter>
</StylesProvider>
</CacheProvider>
</ThemeProvider> |
typescript | this.description = c.description;
this.specificTactics = c.specificTactics;
this.inheritedTactics = c.inheritedTactics ?? '';
this.gwId = c.gwId;
} |
typescript | /// <reference path="../../../References/react-dom.d.ts" />
/// <reference path="../../../References/react-global.d.ts" />
/// <reference path="Icon.d.ts" />
module SpriteMakr.Components.Inputs.Icons {
"use strict"; |
typescript | import { css } from '@emotion/core'
import React from 'react'
import Burger from './burger'
const MenuButton = (props: object) => (
<button css={s.button} type="button" {...props}>
<Burger />
</button> |
typescript | amount,
type: TimerActionTypes.AddTick,
};
};
export const tickerStart = (rate: number = 1000) => {
return (dispatch: any) => {
dispatch(tickerLoop(rate));
return dispatch({
rate,
type: TimerActionTypes.TickerStart,
});
}; |
typescript | export class Favorite {}
|
typescript | styleUrls: ['./accueil.component.css']
})
export class AccueilComponent implements OnInit {
titre = presentation.titre;
experience_label = presentation.experience_label;
texte = presentation.texte;
constructor(private router: Router) { }
getExperience(): string {
return Math.floor(
( new Date().valueOf() - new Date('2008-10-01').valueOf() )
/ (60 * 60 * 24 * 365.25 * 1000)) + ' ' + this.experience_label; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.