repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
KidDevelopper/disc-11
|
src/utils/DiscLogger.ts
|
<filename>src/utils/DiscLogger.ts
import { IDiscLoggerOptions } from "../typings";
import { format } from "date-fns";
enum Colors {
Reset = "\x1b[0m",
Red = "\x1b[31m",
Yellow = "\x1b[33m",
Green = "\x1b[32m",
Blue = "\x1b[34m"
}
export class DiscLogger {
public constructor(public readonly options: IDiscLoggerOptions) {}
public info(...messages: any[]): void {
this.log(messages, "info");
}
public debug(...messages: any[]): void {
this.log(messages, "debug");
}
public error(...messages: any[]): void {
this.log(messages, "error");
}
public warn(...messages: any[]): void {
this.log(messages, "warn");
}
private log(messages: any[], level: "info"|"debug"|"error"|"warn" = "info"): void {
if (this.options.prod && level === "debug") return;
console[level](`${this.options.prod ? "" : (level === "debug" ? Colors.Blue : (level === "error" ? Colors.Red : (level === "warn" ? Colors.Yellow : Colors.Green)))}[${format(Date.now(), "yyyy-MM-dd HH:mm:ss (x)")}] [${level}]: ${messages.map(x => String(x)).join(" ")} ${Colors.Reset}`);
}
}
|
KidDevelopper/disc-11
|
src/commands/general/category.meta.ts
|
<gh_stars>1-10
import i18n from "../../config";
const category = {
name: i18n.__("commands.general.categoryName"),
hide: false
};
export = category;
|
KidDevelopper/disc-11
|
src/commands/music/LyricsCommand.ts
|
import { CommandContext } from "../../structures/CommandContext";
import { ButtonPagination } from "../../utils/ButtonPagination";
import { ILyricsAPIResult, IQueueSong } from "../../typings";
import { BaseCommand } from "../../structures/BaseCommand";
import { createEmbed } from "../../utils/createEmbed";
import { chunk } from "../../utils/chunk";
import i18n from "../../config";
import { AudioPlayerPlayingState, AudioResource } from "@discordjs/voice";
import { Message } from "discord.js";
export class LyricsCommand extends BaseCommand {
public constructor(client: BaseCommand["client"]) {
super(client, {
aliases: ["ly", "lyric"],
description: i18n.__("commands.music.lyrics.description"),
name: "lyrics",
slash: {
options: [
{
description: i18n.__("commands.music.lyrics.slashDescription"),
name: "query",
type: "STRING",
required: false
}
]
},
usage: i18n.__("commands.music.lyrics.usage")
});
}
public execute(ctx: CommandContext): Promise<Message|void> {
const query = ctx.args.length >= 1 ? ctx.args.join(" ") : ctx.options?.getString("query") ? ctx.options.getString("query") : ((((ctx.guild?.queue?.player?.state as AudioPlayerPlayingState).resource as AudioResource | undefined)?.metadata as IQueueSong | undefined)?.song.title);
if (!query) return ctx.reply({ embeds: [createEmbed("error", i18n.__("commands.music.lyrics.noQuery"), true)] });
return this.getLyrics(ctx, query);
}
private async getLyrics(ctx: CommandContext, song: string): Promise<void> {
const url = `https://api.lxndr.dev/lyrics/?song=${encodeURI(song)}&from=${encodeURI(this.client.user!.id)}`;
this.client.request.get(url).json<ILyricsAPIResult<false>>()
.then(async data => {
if ((data as { error: boolean }).error) {
return ctx.reply({ embeds: [createEmbed("error", i18n.__mf("commands.music.lyrics.apiError", { song: `\`${song}\``, message: `\`${(data as {message?: string}).message!}\`` }), true)] });
}
const albumArt = data.album_art ?? "https://api.zhycorp.net/assets/images/icon.png";
const pages: string[] = chunk(data.lyrics as string, 2048);
const embed = createEmbed("info", pages[0]).setAuthor({ name: data.song && data.artist ? `${data.song} - ${data.artist}` : song.toUpperCase() }).setThumbnail(albumArt);
const msg = await ctx.reply({ embeds: [embed] });
return (new ButtonPagination(msg, {
author: ctx.author.id,
edit: (i, e, p) => e.setDescription(p).setFooter({ text: i18n.__mf("reusable.pageFooter", { actual: i + 1, total: pages.length }) }),
embed,
pages
})).start();
})
.catch(error => console.error(error));
}
}
|
KidDevelopper/disc-11
|
src/utils/parseHTMLElements.ts
|
<gh_stars>1-10
export const escapedHTMLElements: Record<string, string> = {
"\"": """,
"&": "&",
"'": "'",
"/": "/",
"<": "<",
"=": "=",
">": ">",
"`": "`"
};
export function parseHTMLElements(text: string): string {
let res = text;
const sortedElements = Object.keys(escapedHTMLElements).sort((a, b) => {
if (a === "&") return 1;
if (b === "&") return -1;
return 0;
});
for (const key of sortedElements) {
res = res.replace(new RegExp(escapedHTMLElements[key], "g"), key);
}
return res;
}
|
aminya/colorize-filter
|
dist/index.d.ts
|
<reponame>aminya/colorize-filter
export declare function test(): string;
/**
* Generates a css filter value for the input hex color.
*/
export declare function generateFilter(hexColor: string): string;
|
proSingularity/obs-twitch-overlay-effects
|
src/dev-config.ts
|
<gh_stars>1-10
export const isProd = true; // manually set true for production
export const DEV = isProd
? {}
: {
enabled: true,
dontConnectToTwitch: true,
enableSceneWatcher: false,
};
|
proSingularity/obs-twitch-overlay-effects
|
src/game-config.ts
|
<gh_stars>1-10
import { Types } from "phaser";
import { DEV } from "./dev-config";
import { MainScene } from "./scenes/MainScene";
interface IPlugin {
key: string;
plugin: any;
}
const isPlugin = (x: false | IPlugin): x is IPlugin => !!x;
const DebugPlugins = [
!!DEV.enableSceneWatcher && {
key: "SceneWatcher",
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
plugin: require("phaser-plugin-scene-watcher"),
},
].filter(isPlugin);
export const gameConfig: Types.Core.GameConfig = {
scene: MainScene,
type: Phaser.AUTO,
dom: {
createContainer: true,
},
// pixelArt: true,
scale: {
mode: Phaser.Scale.FIT,
autoCenter: Phaser.Scale.CENTER_BOTH,
fullscreenTarget: "game",
parent: "game",
width: "100%",
height: "100%",
},
transparent: true,
plugins: {
global: [...DebugPlugins],
},
callbacks: {
postBoot: (game) => {
if (DEV.enableSceneWatcher) {
(game.plugins.get("SceneWatcher") as any).watchAll();
}
},
},
};
|
proSingularity/obs-twitch-overlay-effects
|
src/styles/Color.ts
|
export enum Color {
Black = "#000000",
White = "#ffffff",
WhiteSilver = "#F1F4E7",
Grey = "#7e8079",
DarkGrey = "#222222",
Red = "#f80606",
Green = "#0db80b",
HackerGreen = "#00ff00",
LawnGreen = "#7CFC00",
Yellow = "#FFFF00",
Orange = "#EC6C28",
IceBlue = "#4CAAD4",
Blue = "#3333FF",
HotRed = "#E93A17",
SwitchedOffGrey = "#4e5051",
InBattleWhite = "#d4d4d4",
}
const to0x = (color: Color | string) => color.replace("#", "0x");
export const toHex = (color: Color | string) => parseInt(to0x(color), 16);
|
proSingularity/obs-twitch-overlay-effects
|
src/styles/TextConfig.ts
|
import { GameObjects } from "phaser";
import { Color } from "./Color";
type Style = Partial<GameObjects.TextStyle>;
export const TextConfig: { [key in "md" | "debug"]: Style } = {
md: {
fontFamily: "Helvetica",
fontSize: "12px",
color: "#010001",
},
debug: {
fontFamily: "Courier",
fontSize: "12px",
color: Color.HackerGreen,
},
};
|
proSingularity/obs-twitch-overlay-effects
|
src/scenes/Scenes.ts
|
<filename>src/scenes/Scenes.ts
export enum Scenes {
Main = "MainScene",
}
|
proSingularity/obs-twitch-overlay-effects
|
src/scenes/MainScene.ts
|
import { GUI } from "dat.gui";
import { Scene } from "phaser";
import { ChatUserstate, Client } from "tmi.js";
import { DEV } from "../dev-config";
import { Scenes } from "./Scenes";
const oneMinute = 60000;
const cfg = {};
const tmiConfig = {
options: { debug: true },
connection: {
reconnect: true,
secure: true,
},
channels: ["typescriptteatime"],
};
const banned = ["streamelements"];
export class MainScene extends Scene {
private tmiClient!: Client;
private gui!: GUI;
public constructor() {
super({
key: Scenes.Main,
});
}
public preload() {
this.load
.atlas(
"shapes",
"assets/particles/shapes.png",
"assets/particles/shapes.json"
)
.text("fire-effect", "assets/particles/fire-at-bottom.json")
.text("starshower-effect", "assets/particles/starshower.json");
}
public create(): void {
this.tmiClient = new Client(tmiConfig);
// eslint-disable-next-line @typescript-eslint/no-floating-promises
if (!DEV.dontConnectToTwitch) this.tmiClient.connect();
this.tmiClient.on("message", this.handleMessage.bind(this));
this.gui = new GUI();
this.gui.hide();
if (DEV.enabled) {
this.gui.show();
this.cameras.main.setBackgroundColor("#1E1E1E");
this.gui.add(this, "emitHellFires");
this.gui.add(this, "emitStarshower");
this.gui.add(this, "slash");
}
}
private slash() {
const shape = this.make
.graphics({
x: 0,
y: -1500,
})
.fillRect(0, 0, this.scale.width, 1500);
const mask = shape.createGeometryMask();
// mask.setInvertAlpha();
const slash = this.add.image(
this.scale.width / 2,
300,
"shapes", // TODO less pixelated asset
"slash_03"
);
slash
.setRotation(Phaser.Math.TAU / 4)
.setScale(10)
.setMask(mask);
const timeline = this.tweens.createTimeline();
timeline.add({
targets: [shape],
y: 0,
duration: 400,
});
timeline.add({
delay: 500,
targets: [shape],
y: 1500,
duration: 400,
});
timeline.play();
}
private makeEmitter(key: string) {
return this.add.particles(
"shapes",
// eslint-disable-next-line @typescript-eslint/no-implied-eval
new Function(`return ${this.cache.text.get(key) as string}`)()
);
}
private handleMessage(
channel: string,
tags: ChatUserstate,
message: string,
self: boolean
) {
if (self) return; // Ignore message by chatbot itself
const username = tags.username;
if (!username || banned.includes(username)) return;
const msg = message.toLowerCase();
if (msg.includes("!fire")) return this.emitHellFires();
if (
msg.includes("!star") ||
msg.includes("!starshower") ||
msg.includes("!stars")
) {
return this.emitStarshower();
}
if (msg.includes("!slash") || msg.includes("!slice"))
return this.slash();
}
private emitHellFires() {
const emitter = this.makeEmitter("fire-effect");
if (DEV.enabled) emitter.setY(-80); // not in fullscreen in dev
this.time.delayedCall(oneMinute, () => emitter.destroy());
}
private emitStarshower() {
const emitter = this.makeEmitter("starshower-effect");
this.time.delayedCall(oneMinute, () => emitter.destroy());
}
}
|
lucacasonato/puppeteer_on_deploy
|
deploy.ts
|
<reponame>lucacasonato/puppeteer_on_deploy<gh_stars>1-10
import app from "./main.tsx";
addEventListener("fetch", app.fetchEventHandler());
|
lucacasonato/puppeteer_on_deploy
|
local.ts
|
import app from "./main.tsx";
app.addEventListener("listen", (evt) => {
console.log(`Listening on http://${evt.hostname ?? "localhost"}:${evt.port}`);
});
await app.listen(":8080");
|
lucacasonato/puppeteer_on_deploy
|
main.tsx
|
<reponame>lucacasonato/puppeteer_on_deploy
import { Application, h, puppeteer, renderToString, Router } from "./deps.ts";
import Layout from "./components/Layout.tsx";
const BROWSERLESS_TOKEN = Deno.env.get("BROWSERLESS_TOKEN");
if (BROWSERLESS_TOKEN === undefined) {
throw new TypeError("Missing BROWSERLESS_TOKEN environment variable.");
}
const router = new Router();
router.get("/", (ctx) => {
const rawUrl = ctx.request.url.searchParams.get("url");
let url: URL | null = null;
if (rawUrl !== null) {
try {
url = new URL(rawUrl ?? "");
} catch {
ctx.response.body = "Invalid URL";
ctx.response.status = 400;
return;
}
}
const r = renderToString(
<Layout title="Screenshot!">
<p>
Use this service to take screenshots of websites. Enter the url of the
site below, and press submit. Loading of the image might take a moment.
</p>
<form action="/" method="GET">
<label for="url">URL:</label>
<input
id="url"
name="url"
type="url"
placeholder="URL"
value={url?.href ?? ""}
>
</input>
<button type="submit">Submit</button>
</form>
{url !== null
? (
<div>
<h3>{url.href}</h3>
<img src={`/screenshot.png?url=${url.href}`} />
</div>
)
: null}
</Layout>,
);
ctx.response.body = `<!DOCTYPE html>${r}`;
ctx.response.type = "text/html; charset=utf-8";
});
router.get("/screenshot.png", async (ctx) => {
const rawUrl = ctx.request.url.searchParams.get("url");
let url: URL;
try {
url = new URL(rawUrl ?? "");
} catch {
ctx.response.body = "Invalid URL";
ctx.response.status = 400;
return;
}
if (url.host == "screenshot.deno.dev") {
ctx.response.body = "Nope!";
ctx.response.status = 400;
return;
}
const browser = await puppeteer.connect({
browserWSEndpoint: `wss://chrome.browserless.io?token=${BROWSERLESS_TOKEN}`,
});
try {
const page = await browser.newPage();
await page.goto(url.href, { waitUntil: "domcontentloaded" });
const res = await page.screenshot() as Uint8Array;
ctx.response.body = res;
ctx.response.type = "png";
} finally {
await browser.close();
}
});
const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());
app.addEventListener("error", (err) => console.error(err.message));
export default app;
|
lucacasonato/puppeteer_on_deploy
|
components/Layout.tsx
|
import { ComponentChildren, h } from "../deps.ts";
interface LayoutProps {
title: string;
children: ComponentChildren;
}
export default function Layout(props: LayoutProps) {
return (
<html lang="en">
<head>
<meta charSet="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>{props.title}</title>
</head>
<body>
{props.children}
</body>
</html>
);
}
|
lucacasonato/puppeteer_on_deploy
|
deps.ts
|
export { default as puppeteer } from "https://deno.land/x/puppeteer@9.0.0/mod.ts";
export { Application, Router } from "https://deno.land/x/oak@v7.3.0/mod.ts";
export * from "https://x.lcas.dev/preact@10.5.12/mod.js";
export { renderToString } from "https://x.lcas.dev/preact@10.5.12/ssr.js";
|
exoticknight/SerialPromise
|
src/index.ts
|
<filename>src/index.ts
export interface PromiseGenerator {
(any):Promise<any>
}
export enum StatusCode {
RESOLVE = 0,
REJECT = 1,
TIMEOUT = -1,
}
type ResolveResult = {
status:StatusCode.RESOLVE
data:any
}
type RejectResult = {
status:StatusCode.REJECT
error:any
}
type TimeoutResult = {
status:StatusCode.TIMEOUT
timeout:number
}
interface Resolver {
(result:ResolveResult|RejectResult|TimeoutResult):void
}
export type Progress = {
total:number
resolve:number[]
reject:number[]
timeout:number[]
}
export interface iOnProgress {
(value:Progress):boolean|void
}
export default function SerialPromise(
promises:PromiseGenerator[],
timeouts:number[]=[],
wait:number[]|number=0,
onProgress:iOnProgress=()=>void 0
):Promise<any> {
return new Promise((resolve) => {
const totalCount = promises.length
const resolveQueue = []
const rejectQueue = []
const timeoutQueue = []
const rets = []
rets[-1] = null
const waitTimes = Array.isArray(wait) ? wait : [0, ...Array(promises.length-1).fill(wait)]
function worker(i) {
let stop = false
let timer
let ret
if (timeouts[i]) {
let timeoutHandler
let end = false
ret = [
new Promise((resolve:Resolver) => {
timeoutHandler = setTimeout(() => {
if (!end) {
end = true
timeoutQueue.push(i)
onProgress({
total: totalCount,
resolve: resolveQueue.slice(0),
reject: rejectQueue.slice(0),
timeout: timeoutQueue.slice(0),
})
resolve({ status: StatusCode.TIMEOUT, timeout:timeouts[i] })
}
}, timeouts[i])
}),
new Promise((resolve:Resolver) => {
promises[i](rets[i-1]).then(d => {
if (!end) {
end = true
clearTimeout(timeoutHandler)
resolveQueue.push(i)
onProgress({
total: totalCount,
resolve: resolveQueue.slice(0),
reject: rejectQueue.slice(0),
timeout: timeoutQueue.slice(0),
})
resolve({ status: StatusCode.RESOLVE, data: d })
}
}).catch(d => {
if (!end) {
end = true
clearTimeout(timeoutHandler)
rejectQueue.push(i)
onProgress({
total: totalCount,
resolve: resolveQueue.slice(0),
reject: rejectQueue.slice(0),
timeout: timeoutQueue.slice(0),
})
resolve({ status: StatusCode.REJECT, error: d })
}
})
}),
]
} else {
ret = [
new Promise((resolve:Resolver) => {
promises[i](rets[i-1]).then(d => {
resolveQueue.push(i)
onProgress({
total: totalCount,
resolve: resolveQueue.slice(0),
reject: rejectQueue.slice(0),
timeout: timeoutQueue.slice(0),
})
resolve({ status: StatusCode.RESOLVE, data: d })
}).catch(d => {
rejectQueue.push(i)
onProgress({
total: totalCount,
resolve: resolveQueue.slice(0),
reject: rejectQueue.slice(0),
timeout: timeoutQueue.slice(0),
})
resolve({ status: StatusCode.REJECT, error: d })
})
})
]
}
Promise.race(ret).then(result => {
rets.push(result)
if (stop || promises.length === i + 1) {
clearTimeout(timer)
delete rets[-1]
resolve(rets)
} else {
timer = setTimeout(() => {
clearTimeout(timer)
timer = null
worker(i + 1)
}, waitTimes[i] || 0);
}
})
}
worker(0)
})
}
|
exoticknight/SerialPromise
|
test/index.spec.ts
|
<gh_stars>1-10
import test from 'tape'
import SerialPromise, { StatusCode } from '../src/index'
function generatePromise(isRes, timeout) {
return new Promise((res, rej) => {
setTimeout(() => {
if (isRes) {
res('resolve')
} else {
rej('reject')
}
}, timeout)
})
}
test('normal queue', async function(t) {
const rets = await SerialPromise(
[
() => {
return generatePromise(true, 1000)
},
() => {
return generatePromise(false, 1000)
}
],
[2000, 2000],
500,
x => {console.log(x)}
)
t.equal(rets[0].status, StatusCode.RESOLVE, 'should resovle')
t.equal(rets[1].status, StatusCode.REJECT, 'should reject')
t.end()
})
test('timeout queue', async function(t) {
const rets = await SerialPromise(
[
() => {
return generatePromise(true, 2000)
},
() => {
return generatePromise(false, 2000)
}
],
[1000, 1000],
500,
() => {}
)
t.equal(rets[0].status, StatusCode.TIMEOUT, 'should timeout')
t.equal(rets[1].status, StatusCode.TIMEOUT, 'should timeout')
t.end()
})
test('pass status', async function(t) {
const rets = await SerialPromise(
[
r => {
t.equal(r, null, 'null for the first time')
return generatePromise(true, 500)
},
r => {
t.deepEqual(r, { status: StatusCode.RESOLVE, data: 'resolve' }, 'pass resolve')
return generatePromise(false, 500)
},
r => {
t.deepEqual(r, { status: StatusCode.REJECT, error: 'reject' }, 'pass reject')
return generatePromise(false, 2000)
},
r => {
t.deepEqual(r, { status: StatusCode.TIMEOUT, timeout: 1000 }, 'pass timeout')
return generatePromise(true, 500)
}
],
[1000, 1000, 1000,],
500,
() => {}
)
t.deepEqual(rets[rets.length-1], { status: StatusCode.RESOLVE, data: 'resolve' }, 'pass anyway')
t.end()
})
test('onProgress', async function(t) {
const sequence = []
await SerialPromise(
[
() => {
return generatePromise(true, 500)
},
() => {
return generatePromise(false, 500)
},
() => {
return generatePromise(false, 2000)
},
],
[1000, 1000, 1000],
500,
progress => {
sequence.push(progress)
}
)
t.deepEqual(sequence[0], {
total: 3,
resolve: [0],
reject: [],
timeout: []
})
t.deepEqual(sequence[1], {
total: 3,
resolve: [0],
reject: [1],
timeout: []
})
t.deepEqual(sequence[2], {
total: 3,
resolve: [0],
reject: [1],
timeout: [2]
})
t.end()
})
test('get all results', async function(t) {
const rets = await SerialPromise(
[
() => {
return generatePromise(true, 500)
},
() => {
return generatePromise(false, 500)
},
() => {
return generatePromise(false, 2000)
},
],
[1000, 1000, 1000],
500,
() => {}
)
t.deepEqual(rets[0], { status: StatusCode.RESOLVE, data: 'resolve' }, 'should get resolve data')
t.deepEqual(rets[1], { status: StatusCode.REJECT, error: 'reject' }, 'should get reject error')
t.deepEqual(rets[2], { status: StatusCode.TIMEOUT, timeout: 1000 }, 'should get timeout')
t.end()
})
|
exoticknight/SerialPromise
|
dist/index.d.ts
|
<reponame>exoticknight/SerialPromise
export interface PromiseGenerator {
(any: any): Promise<any>;
}
export declare enum StatusCode {
RESOLVE = 0,
REJECT = 1,
TIMEOUT = -1
}
export declare type Progress = {
total: number;
resolve: number[];
reject: number[];
timeout: number[];
};
export interface iOnProgress {
(value: Progress): boolean | void;
}
export default function SerialPromise(promises: PromiseGenerator[], timeouts?: number[], wait?: number[] | number, onProgress?: iOnProgress): Promise<any>;
|
andrzejrumak/50pdev
|
nuxt.config.ts
|
import { defineNuxtConfig } from "nuxt3";
export default defineNuxtConfig({});
|
bennymeg/AcademicEmailVerifier
|
index.d.ts
|
<filename>index.d.ts
/**
* Copyright 2019 <NAME>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author <NAME>
*/
export declare class Verifier {
/**
* check's if the email address is valid (in an proper email format - RFC 2822)
* @param {string} emailAddress email address to be checked
* @returns {boolean} true, if the email address is valid, false, otherwise
*/
static isValidEmailAddress(emailAddress: string): boolean
/**
* check's if the email address is academic
* @param {string} emailAddress email address to be checked
* @returns {Promise<boolean>} true, if the email address is academic, false, otherwise
*/
static isAcademic(emailAddress: string): Promise<boolean>
/**
* query email address institution name
* @param {string} emailAddress email address to be checked
* @returns {Promise<string>} academic institution name, if exist, '', otherwise
*/
static getInstitutionName(emailAddress: string): Promise<string>
}
|
PrataGabriel/app-interface-react-native
|
modernui/App.tsx
|
<reponame>PrataGabriel/app-interface-react-native<gh_stars>0
import React from "react"
import {Home} from "./src/screens/Home"
export default function App() {
return (
<Home />
)
}
|
PrataGabriel/app-interface-react-native
|
modernui/src/screens/Home/index.tsx
|
import React from "react"
import {View, Text} from "react-native"
export function Home()
{
return (
<View style={{flex: 1, justifyContent: 'center', alignItems: 'center'}}>
<Text>Home</Text>
</View>
)
}
|
pushkar8723/react-boilerplate
|
src/app.ts
|
import { initApp, pushStateLocationPlugin, RoutingService, Transition } from '@sparkx/react';
import { HTTPService } from '@sparkx/services';
import routes from 'config/routes';
import * as ReactDOM from 'react-dom';
import LocalStorageService from 'services/LocalStorageService';
import Notification, { NOTIFICATION_POSITION } from 'sleek-ui/Notification';
import './styles/main.css';
import { AccessType, IGlobal } from './types';
const localStorageService = new LocalStorageService();
const routingService = new RoutingService();
const httpService = new HTTPService();
ReactDOM.render(
initApp<IGlobal>(
(setGlobal) => {
// Set auth in global scope if present in localstorage.
const auth = localStorageService.get('auth');
if (auth) {
setGlobal({
auth,
});
}
const interceptor = httpService.getInterceptors();
// Register request handler interceptor
interceptor.request.use(
(response: any) => {
setGlobal({ inProgress: true });
return response;
},
);
// Register response handler interceptor
interceptor.response.use(
(response: any) => {
setGlobal({ inProgress: false });
return response;
},
(error: any) => {
setGlobal({ inProgress: false });
if (!error.config.errorHandled) {
Notification.add(NOTIFICATION_POSITION.TOP_RIGHT, {
content: 'Request failed. If error persists, contact admin.',
state: 'danger',
title: 'Oops! Something went wrong',
});
}
return error;
},
);
// Register plugin
routingService.registerPlugin(pushStateLocationPlugin);
// Register routes.
routingService.registerRoutes(routes);
// Setting starting route.
routingService.setInitialState('welcome');
// Setting fallback route.
routingService.set404State('404');
// Register hook for page title.
routingService.registerSuccessHook((transition: Transition) => {
const { data } = transition.router.globals.current;
const title = `${data && data.pageTitle ? `${data.pageTitle} - ` : ''}Books`;
document.title = title;
});
// Register hook for authentication check.
routingService.registerBeforeHook((transition: Transition) => {
const toState = transition.to();
const authObj = localStorageService.get('auth');
if (toState.data.access === AccessType.AUTHENTICATED && !authObj) {
return transition.router.stateService.target('welcome');
}
if (toState.data.access === AccessType.UNAUTHENTICATED && authObj) {
return transition.router.stateService.target('books');
}
});
},
__MODE__,
),
document.getElementById('root'),
);
|
pushkar8723/react-boilerplate
|
src/views/Books/Detail/Detail.tsx
|
import { IInjectedProps } from '@sparkx/react';
import * as React from 'react';
import Loader from 'sleek-ui/Loader';
import styled from 'styled-components';
import bookIcon from '../../../images/bookIcon.png';
import { IGlobal } from '../../../types';
import { Error404 } from '../../Error';
import { IDetailState } from './DetailCtrl';
const Container = styled.div`
flex: 1;
max-width: 1024px;
padding: 8px;
margin: 0 auto;
`;
const HeroContainer = styled.div`
display: flex;
min-height: 166px;
`;
const ThumbnailContainer = styled.div`
margin-right: 8px;
min-height: 150px;
width: 120px;
align-items: center;
& > img {
max-width: 100%;
max-height: 100%;
}
`;
const TextContainer = styled.div`
display: flex;
flex-direction: column;
justify-content: flex-start;
flex: 1;
`;
const Title = styled.h1`
margin: 0 0 5px 0;
`;
const DescriptionContainer = styled.div`
text-align: justify;
`;
const Label = styled.div`
font-size: 12px;
font-weight: bold;
`;
const P = styled.div`
margin-bottom: 10px;
`;
interface IDetailProps extends IInjectedProps<IGlobal, IDetailState> {
/**
* Fetches book's detail
*/
getBook: (bookId: string) => void;
}
/**
* Books Detail page's component
*/
class Detail extends React.Component<IDetailProps> {
constructor(props: IDetailProps) {
super(props);
this.props.getBook(props.$stateParams.id);
}
/**
* Renders the book's information.
*/
private renderBook = () => {
const { volumeInfo } = this.props.scope.data;
return (
<Container>
<HeroContainer>
<ThumbnailContainer>
<img
src={volumeInfo.imageLinks && volumeInfo.imageLinks.thumbnail ||
bookIcon}
/>
</ThumbnailContainer>
<TextContainer>
<Title>{volumeInfo.title}</Title>
<div>{volumeInfo.subtitle}</div>
<h4>{volumeInfo.publisher}</h4>
{
volumeInfo.averageRating ?
<div>
<strong>Rating: </strong>
{volumeInfo.averageRating} / 5 ({volumeInfo.ratingsCount})
</div> :
<div>Not rated yet!</div>
}
</TextContainer>
</HeroContainer>
<DescriptionContainer>
<h3>Description</h3>
<div
dangerouslySetInnerHTML={{
__html: volumeInfo.description,
}}
/>
</DescriptionContainer>
<DescriptionContainer>
<h3>Additional Information</h3>
<P>
<Label>Page Count</Label>
<div>{volumeInfo.pageCount}</div>
</P>
{
volumeInfo.categories &&
<P>
<Label>Categories</Label>
<div>
{volumeInfo.categories.map(category =>
<div key={category}>{category}</div>)}
</div>
</P>
}
{
volumeInfo.industryIdentifiers &&
<P>
<Label>ISBN</Label>
<div>
{volumeInfo.industryIdentifiers.map(identifier =>
<div key={identifier.identifier}>
{identifier.type} : {identifier.identifier}
</div>)}
</div>
</P>
}
</DescriptionContainer>
</Container>
);
}
/**
* Render method.
*/
public render() {
if (this.props.global.inProgress) {
return <Loader centered={true} />;
}
if (!this.props.scope.data) {
return <Error404 />;
}
return this.renderBook();
}
}
export default Detail;
|
pushkar8723/react-boilerplate
|
test/views/Books/BooksCtrl.test.ts
|
import { RoutingService } from '@sparkx/react';
import GoogleBooksService from 'services/GoogleBooksService';
import LocalStorage from 'services/LocalStorageService';
import BooksCtrl from 'views/Books/BooksCtrl';
import bookSearchResponse from './BooksSearch.json';
let ctrl: BooksCtrl;
let setScope: () => void;
let setGlobal: () => void;
const authMock = {
email: '<EMAIL>',
};
jest.mock('services/LocalStorageService');
jest.mock('@sparkx/react');
jest.mock('services/GoogleBooksService');
describe('Books Controller Tests', () => {
beforeEach(() => {
setScope = jest.fn();
setGlobal = jest.fn();
LocalStorage.mockClear();
RoutingService.mockClear();
GoogleBooksService.mockClear();
ctrl = new BooksCtrl({}, setScope, {}, setGlobal);
});
it('Test Load Book Success', () => {
const googleBooksService = GoogleBooksService.mock.instances[0];
googleBooksService.searchBooks = jest.fn(() =>
Promise.resolve(bookSearchResponse.response));
expect.assertions(2);
const promise = ctrl.loadBook('A song of ice and fire');
expect(googleBooksService.searchBooks).toHaveBeenCalledWith('A song of ice and fire');
return promise.then(() => {
expect(setScope).toHaveBeenCalledWith({
books: bookSearchResponse.parsedResp,
});
});
});
it('Test Logout', () => {
const localStorageInstance = LocalStorage.mock.instances[0];
const removeMock = localStorageInstance.remove;
const routingServiceInstance = RoutingService.mock.instances[0];
const goToMock = routingServiceInstance.goTo;
ctrl.logout();
expect(setGlobal).toHaveBeenCalledWith({ auth: undefined });
expect(removeMock).toHaveBeenCalledWith('auth');
expect(goToMock).toHaveBeenCalledWith('welcome');
});
});
|
pushkar8723/react-boilerplate
|
test/views/Welcome/WelcomeCtrl.test.ts
|
import { RoutingService } from '@sparkx/react';
import LocalStorage from 'services/LocalStorageService';
import WelcomeCtrl from 'views/Welcome/WelcomeCtrl';
let ctrl;
let setScope;
let setGlobal: () => void;
const mockData = {
email: '<EMAIL>',
familyName: 'Anand',
givenName: 'Pushkar',
name: '<NAME>',
};
jest.mock('@sparkx/react');
jest.mock('services/LocalStorageService');
describe('Welcome Controller Tests', () => {
beforeEach(() => {
RoutingService.mockClear();
setScope = jest.fn();
setGlobal = jest.fn();
ctrl = new WelcomeCtrl({}, setScope, {}, setGlobal);
ctrl.login({ profileObj: mockData });
});
it('Test Local Storage Update', () => {
const localStorageInstance = LocalStorage.mock.instances[0];
const setMock = localStorageInstance.set;
expect(setMock.mock.calls.length).toBe(1);
expect(setMock).toHaveBeenCalledWith('auth', mockData);
});
it('Test Login Redirect', () => {
const routingServiceInstance = RoutingService.mock.instances[0];
const goToMock = routingServiceInstance.goTo;
expect(goToMock.mock.calls.length).toBe(1);
expect(goToMock).toHaveBeenCalledWith('books');
});
it('Test Login to update Global auth', () => {
expect(setGlobal.mock.calls.length).toBe(1);
expect(setGlobal).toHaveBeenCalledWith({ auth: mockData });
});
});
|
pushkar8723/react-boilerplate
|
src/types.ts
|
export interface IGlobal {
/**
* Auth object
*/
auth: any;
/**
* Flag to denote if any api is in progress
*/
inProgress: boolean;
}
export enum AccessType {
ALL = 'all',
UNAUTHENTICATED = 'unauthenticated',
AUTHENTICATED = 'authenticated',
}
|
pushkar8723/react-boilerplate
|
test/services/GoogleBooksService.test.ts
|
<gh_stars>1-10
import { HTTPService } from '@sparkx/services';
import GoogleBooksService from 'services/GoogleBooksService';
let service: GoogleBooksService;
const endpoint = 'https://www.googleapis.com/books/v1';
jest.mock('@sparkx/services');
describe('Test Google Books Service', () => {
beforeEach(() => {
HTTPService.mockClear();
service = new GoogleBooksService();
});
it('Test Search Books', () => {
const httpServiceInstance = HTTPService.mock.instances[0];
service.searchBooks('test');
expect(httpServiceInstance.get).toHaveBeenCalledWith(`${endpoint}/volumes`, {
maxResults: '20',
q: 'test',
startIndex: '0',
});
});
it('Test Search Books pagination', () => {
const httpServiceInstance = HTTPService.mock.instances[0];
service.searchBooks('test', 2, 10);
expect(httpServiceInstance.get).toHaveBeenCalledWith(`${endpoint}/volumes`, {
maxResults: '10',
q: 'test',
startIndex: '2',
});
});
it('Test Get Book', () => {
const httpServiceInstance = HTTPService.mock.instances[0];
service.getBook('test');
expect(httpServiceInstance.get).toHaveBeenCalledWith(
`${endpoint}/volumes/test`, null, null,
{ errorHandled: undefined },
);
});
});
|
pushkar8723/react-boilerplate
|
src/views/Books/Books.tsx
|
import { IInjectedProps, UISref, UIView } from '@sparkx/react';
import * as React from 'react';
import Drawer from 'sleek-ui/Drawer';
import styled from 'styled-components';
import { IGlobal } from '../../types';
const Toolbar = styled.div`
min-height: 64px;
display: flex;
align-items: center;
padding: 0 4px 0 16px;
box-shadow: 0 0 3px rgba(0,0,0,0.2);
justify-content: center;
z-index: 1;
`;
const Form = styled.form`
flex: 1;
display: flex;
`;
const Input = styled.input`
border: none;
height: 40px;
font-size: 18px;
padding: 0 16px;
flex: 1;
`;
const Icon = styled.i`
height: 24px;
width: 24px;
border-radius: 2px;
padding: 8px;
cursor: pointer;
vertical-align: middle;
&:hover {
background-color: #f2f2f2;
}
`;
const MenuIcon = styled.i`
height: 24px;
width: 24px;
border-radius: 2px;
cursor: pointer;
vertical-align: middle;
margin-right: 10px;
`;
const DrawerHeaderContainer = styled.div`
display: flex;
align-items: center;
`;
const DrawerHeaderText = styled.div`
padding-left: 16px;
`;
const UIViewContainer = styled.div`
display: flex;
flex: 1;
overflow: auto;
`;
const ListItem = styled.a`
display: block;
padding: 16px;
background-color: #fff;
border: none;
font-size: 14px;
text-decoration: none;
color: #000;
line-height: 24px;
cursor: pointer;
&:hover {
background-color: #f2f2f2;
}
`;
const NameContainer = styled.h4`
margin-bottom: 8px;
`;
interface IBooksProps extends IInjectedProps<IGlobal, IBooksState> {
/**
* Loads a book
*/
loadBook: (bookName: string) => void;
/**
* Logs out the user
*/
logout: () => void;
}
interface IBooksState {
/**
* Search text
*/
inputText: string;
/**
* Flag to denote if drawer is open.
*/
open: boolean;
}
/**
* Root Books class
*/
class Books extends React.Component<IBooksProps, IBooksState> {
constructor(props: IBooksProps) {
super(props);
this.state = {
inputText: '',
open: false,
};
}
/**
* Toggles the drawer.
*/
private toggleDrawer = () => {
this.setState({
open: !this.state.open,
});
}
/**
* Renders the drawer header.
*/
private renderDrawerHeader = () => {
if (this.props.global && this.props.global.auth) {
return (
<DrawerHeaderContainer>
<i className="material-icons">account_circle</i>
<DrawerHeaderText>
<NameContainer>{this.props.global.auth.name}</NameContainer>
<h5>{this.props.global.auth.email}</h5>
</DrawerHeaderText>
</DrawerHeaderContainer>
);
}
return null;
}
/**
* Handles the onChange event of the input field.
*/
private handleInputTextChange = (event: React.SyntheticEvent) => {
const value = event.target.value;
this.setState({
inputText: value,
});
}
/**
* Search for a Book.
*/
private searchBook = (event: React.SyntheticEvent) => {
event.preventDefault();
this.props.loadBook(this.state.inputText);
return false;
}
/**
* Render function
*/
public render() {
return (
<React.Fragment>
<Toolbar>
<i className="material-icons">search</i>
<Form onSubmit={this.searchBook}>
<Input
onChange={this.handleInputTextChange}
placeholder="Search a book ..."
value={this.state.inputText}
required={true}
/>
</Form>
<Icon
className="material-icons"
onClick={this.toggleDrawer}
>
menu
</Icon>
</Toolbar>
<Drawer
open={this.state.open}
headerContent={this.renderDrawerHeader()}
data={<React.Fragment>
<ListItem onClick={this.toggleDrawer}>
<UISref to="books">
<div>
<MenuIcon className="material-icons">home</MenuIcon>
Home
</div>
</UISref>
</ListItem>
<ListItem onClick={this.props.logout}>
<MenuIcon className="material-icons">exit_to_app</MenuIcon>
Logout
</ListItem>
</React.Fragment>}
closeOnEsc={true}
handleOverlayLayerClick={this.toggleDrawer}
width={320}
/>
<UIViewContainer>
<UIView />
</UIViewContainer>
</React.Fragment>);
}
}
export default Books;
|
pushkar8723/react-boilerplate
|
src/services/LocalStorageService.ts
|
<filename>src/services/LocalStorageService.ts
import { ServiceBase } from '@sparkx/core';
/**
* Service for localStorage management.
*/
export default class LocalStorageService extends ServiceBase {
/**
* Returns the value for the given key.
*/
public get(key: string): any {
return JSON.parse(localStorage.getItem(key));
}
/**
* Sets the value of given key to given data.
*/
public set(key: string, data: any) {
localStorage.setItem(key, JSON.stringify(data));
}
/**
* Removes the given key from local storage.
*/
public remove(key: string) {
localStorage.removeItem(key);
}
}
|
pushkar8723/react-boilerplate
|
src/views/Error/index.ts
|
<reponame>pushkar8723/react-boilerplate
export { default as Error404 } from './Error404';
|
pushkar8723/react-boilerplate
|
src/views/Welcome/index.ts
|
<gh_stars>1-10
export { default as Welcome } from './Welcome';
export { default as WelcomeCtrl } from './WelcomeCtrl';
|
pushkar8723/react-boilerplate
|
src/global.d.ts
|
declare const __MODE__: string;
|
pushkar8723/react-boilerplate
|
src/views/Welcome/WelcomeCtrl.ts
|
import { ControllerBase } from '@sparkx/core';
import { RoutingService } from '@sparkx/react';
import LocalStorageService from 'services/LocalStorageService';
import { IGlobal } from '../../types';
/**
* Welcome Controller
*/
class WelcomeCtrl extends ControllerBase<undefined, IGlobal> {
/**
* Local storage service
*/
private _storage: LocalStorageService = new LocalStorageService();
/**
* Routing Service
*/
private _routingService: RoutingService = new RoutingService();
/**
* Logs in the user.
*/
public login = (response: any) => {
this._storage.set('auth', response.profileObj);
this._routingService.goTo('books');
this._setGlobal({
auth: response.profileObj,
});
}
}
export default WelcomeCtrl;
|
pushkar8723/react-boilerplate
|
src/services/GoogleBooksService.ts
|
<gh_stars>1-10
import { ServiceBase } from '@sparkx/core';
import { AxiosPromise, HTTPService } from '@sparkx/services';
interface IISBN {
/**
* Type of ISBN
*/
type: string;
/**
* ISBN number
*/
identifier: number;
}
interface IBookList {
/**
* Items in list
*/
items: IBookDetail[];
}
export interface IBookDetail {
/**
* Book ID
*/
id: string;
/**
* Book info
*/
volumeInfo: {
/**
* Authors
*/
authors: string[],
/**
* Average Rating
*/
averageRating: number,
/**
* Book categories
*/
categories: string[],
/**
* Description for book
*/
description: string,
/**
* Thumbnails for the book
*/
imageLinks: {
/**
* Standard size thumbnail
*/
thumbnail: string,
}
/**
* ISBN numbers
*/
industryIdentifiers: IISBN[],
/**
* Number of pages in book
*/
pageCount: number,
/**
* Publisher for the book
*/
publisher: string,
/**
* Book's rating
*/
ratingsCount: number,
/**
* Book's subtitle
*/
subtitle: string,
/**
* Book's title
*/
title: string,
};
}
/**
* Service for Google Books apis.
*/
class GoogleBooksService extends ServiceBase {
/**
* Google Books Endpoint for apis.
*/
private endpoint = 'https://www.googleapis.com/books/v1';
/**
* Reference for HTTP service.
*/
private httpService = new HTTPService();
/**
* API to search for book by name.
*/
public searchBooks(bookName: string, start: number = 0, items: number = 20)
: AxiosPromise<IBookList> {
return this.httpService.get(`${this.endpoint}/volumes`, {
maxResults: items.toString(),
q: bookName,
startIndex: start.toString(),
});
}
/**
* API to get book by ID
*/
public getBook(id: string, errorHandled?: boolean): AxiosPromise<IBookDetail> {
return this.httpService.get(`${this.endpoint}/volumes/${id}`, null, null, { errorHandled });
}
}
export default GoogleBooksService;
|
pushkar8723/react-boilerplate
|
src/views/Books/index.ts
|
<filename>src/views/Books/index.ts
import { createRoute } from '@sparkx/react';
import { AccessType } from '../../types';
import Books from './Books';
import BooksCtrl from './BooksCtrl';
import { Detail, DetailCtrl } from './Detail';
import { Search } from './Search';
const booksState = createRoute({
component: Books,
controller: BooksCtrl,
data: {
access: AccessType.AUTHENTICATED,
pageTitle: 'Books',
},
name: 'books',
redirectTo: 'books.search',
url: '/books',
});
const booksSearchState = createRoute({
component: Search,
data: {
access: AccessType.AUTHENTICATED,
pageTitle: 'Books Search',
},
name: 'books.search',
url: '/',
});
const booksDetailState = createRoute({
component: Detail,
controller: DetailCtrl,
data: {
access: AccessType.AUTHENTICATED,
pageTitle: 'Books Detail',
},
name: 'books.detail',
url: '/:id',
});
export const states = [booksState, booksSearchState, booksDetailState];
|
pushkar8723/react-boilerplate
|
test/services/LocalStorageService.test.ts
|
<reponame>pushkar8723/react-boilerplate
import LocalStorageService from 'services/LocalStorageService';
let service: LocalStorageService;
describe('Test Local Storage Service', () => {
beforeEach(() => {
service = new LocalStorageService();
});
it('Test Get', () => {
const spy = jest.spyOn(Storage.prototype, 'getItem');
service.get('auth');
expect(spy).toHaveBeenCalledWith('auth');
});
it('Test Set', () => {
const spy = jest.spyOn(Storage.prototype, 'setItem');
const mockObj = { a: 'b' };
service.set('auth', mockObj);
expect(spy).toHaveBeenCalledWith('auth', JSON.stringify(mockObj));
});
it('Test Remove', () => {
const spy = jest.spyOn(Storage.prototype, 'removeItem');
service.remove('auth');
expect(spy).toHaveBeenCalledWith('auth');
});
});
|
pushkar8723/react-boilerplate
|
src/views/Welcome/Welcome.tsx
|
<filename>src/views/Welcome/Welcome.tsx
import { IInjectedProps } from '@sparkx/react';
import * as React from 'react';
import { GoogleLogin } from 'react-google-login';
import Notification, { NOTIFICATION_POSITION } from 'sleek-ui/Notification';
import styled from 'styled-components';
import logoPng from '../../images/logo.png';
import { IGlobal } from '../../types';
const Page = styled.div`
flex: 1;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
background: linear-gradient(160deg, transparent 80vh, #F3F4F5 80vh, white 100vh),
linear-gradient(to bottom, #F3F4F5 160px, white 50vh), white;
`;
const LoginContainer = styled.div`
height: 280px;
width: 280px;
background-color: #fff;
box-shadow: rgba(0,0,0,0.2) 0 1px 2px;
border-radius: 2px;
padding: 10px;
text-align: center;
display: flex;
flex-direction: column;
`;
const WelcomeTextContainer = styled.div`
display: flex;
flex-direction: column;
flex: 1;
align-items: center;
justify-content: center;
`;
const LogoImage = styled.img`
width: 150px;
height: 150px;
margin-bottom: -50px;
z-index: 1;
`;
interface IWelcomeProps extends IInjectedProps<IGlobal, undefined> {
/**
* Logs in the user
*/
login: (response: any) => void;
}
/**
* Test class
*/
class Welcome extends React.Component<IWelcomeProps> {
/**
* Shows error notification in case of failed login attempt.
*/
private showError = (response: any) => {
Notification.add(NOTIFICATION_POSITION.TOP_RIGHT, {
content: response.error,
state: 'danger',
title: 'Login Failed',
});
}
/**
* Render method for test component.
*/
public render() {
return (
<Page>
<LogoImage src={logoPng} alt="Logo" />
<LoginContainer>
<h1>Books</h1>
<WelcomeTextContainer>
<h4>Welcome!</h4>
<h5>Login using your Google ID to continue.</h5>
</WelcomeTextContainer>
<div>
<hr/>
<GoogleLogin
// tslint:disable-next-line
clientId='957313973766-bqf56eeu9v5uek2d9ftlaq94h3q3tknd.apps.googleusercontent.com'
onSuccess={this.props.login}
onFailure={this.showError}
buttonText="Login with Google"
/>
</div>
</LoginContainer>
</Page>
);
}
}
export default Welcome;
|
pushkar8723/react-boilerplate
|
src/views/Books/Search/Search.tsx
|
import { IInjectedProps, UISref } from '@sparkx/react';
import * as React from 'react';
import Loader from 'sleek-ui/Loader';
import styled from 'styled-components';
import bookIcon from '../../../images/bookIcon.png';
import searchGif from '../../../images/search.gif';
import { IGlobal } from '../../../types';
const Container = styled.div`
display: flex;
flex: 1;
align-items: center;
justify-content: center;
flex-direction: column;
`;
const SearchImage = styled.img`
margin-top: -120px;
margin-bottom: -80px;
`;
const List = styled.div`
display: flex;
flex: 1;
flex-direction: column;
max-width: 1024px;
margin: 0 auto;
`;
const ListItem = styled.a`
padding: 8px;
display: flex;
border-bottom: 1px solid #eee;
text-decoration: none;
color: #000;
min-height: 166px;
&:hover {
background-color: #f2f2f2;
}
`;
const ThumbnailContainer = styled.div`
margin-right: 8px;
min-height: 150px;
width: 120px;
align-items: center;
& > img {
max-width: 100%;
max-height: 100%;
}
`;
const TextContainer = styled.div`
display: flex;
flex-direction: column;
justify-content: center;
flex: 1;
`;
interface IBook {
/** Book's authors */
authors: string[];
/** Book's unique identifier */
id: string;
/** Book's title */
title: string;
/** Book's subtitle */
subtitle: string;
/** Book's publisher */
publisher: string;
/** Standard size thumbnail for the book */
thumbnail: string;
}
interface ISearchProps extends IInjectedProps<IGlobal, {
/** Book list */
books: IBook[];
}> {}
/**
* Books Search page.
*/
export default class Search extends React.Component<ISearchProps> {
/**
* Renders a book
*/
private renderListItem = (book: IBook) => {
return (
<UISref key={book.id} to="books.detail" params={{ id: book.id }}>
<ListItem>
<ThumbnailContainer>
<img src={book.thumbnail || bookIcon} />
</ThumbnailContainer>
<TextContainer>
<h4>{book.title}</h4>
<div>{book.subtitle}</div>
<div>{book.authors && book.authors.join(', ')}</div>
<h5>{book.publisher}</h5>
</TextContainer>
</ListItem>
</UISref>
);
}
/**
* Render Function.
*/
public render() {
const { scope, global } = this.props;
return (
<React.Fragment>
{
global.inProgress ?
<Loader centered={true} /> :
scope.books ?
<List>
{scope.books.map((book: IBook) => this.renderListItem(book))}
</List> :
<Container>
<SearchImage src={searchGif} />
<div>Search a book to begin.</div>
</Container>
}
</React.Fragment>
);
}
}
|
pushkar8723/react-boilerplate
|
src/views/Books/Detail/index.ts
|
export { default as Detail } from './Detail';
export { default as DetailCtrl } from './DetailCtrl';
|
pushkar8723/react-boilerplate
|
src/views/Error/Error404.tsx
|
<filename>src/views/Error/Error404.tsx
import { UISref } from '@sparkx/react';
import * as React from 'react';
import styled from 'styled-components';
import noPageGif from '../../images/noPage.gif';
const Container = styled.div`
display: flex;
align-items: center;
justify-content: center;
flex: 1;
flex-direction: column;
background: linear-gradient(160deg, transparent 80vh, #F3F4F5 80vh, white 100vh),
linear-gradient(to bottom, #F3F4F5 160px, white 50vh), white;
`;
const Paper = styled.div`
width: 320px;
background-color: #fff;
box-shadow: rgba(0,0,0,0.2) 0 1px 2px;
border-radius: 2px;
padding: 10px;
text-align: center;
& > img {
max-width: 100%;
}
`;
/**
* Component to render 404 error page
*/
export default class Error404 extends React.Component<{}> {
/**
* Render function
*/
public render() {
return (
<Container>
<Paper>
<img src={noPageGif} />
<h3>404 - Page not found :(</h3>
<UISref to="welcome"><a>Go Home</a></UISref>
</Paper>
</Container>
);
}
}
|
pushkar8723/react-boilerplate
|
src/views/Books/Detail/DetailCtrl.ts
|
import { ControllerBase } from '@sparkx/core';
import GoogleBooksService, { IBookDetail } from 'services/GoogleBooksService';
import { IGlobal } from '../../../types';
export interface IDetailState {
/** Book details */
data: IBookDetail;
}
/**
* Detail Controller
*/
class DetailCtrl extends ControllerBase<IDetailState, IGlobal> {
/**
* Google Book Service
*/
private _googleBooksService = new GoogleBooksService();
/**
* Retrives the book with the given Id
* @param id
*/
public getBook = (id: string) => {
return this._googleBooksService.getBook(id, true).then(
(resp: any) => {
this._setScope({ data: resp.data });
},
() => {
this._setScope({ data: undefined });
},
);
}
}
export default DetailCtrl;
|
pushkar8723/react-boilerplate
|
test/views/Books/Detail/DetailCtrl.test.ts
|
<reponame>pushkar8723/react-boilerplate<gh_stars>1-10
import GoogleBooksService from 'services/GoogleBooksService';
import DetailCtrl from 'views/Books/Detail/DetailCtrl';
import bookDetail from './BookDetail.json';
let ctrl: DetailCtrl;
let setScope: () => void;
let setGlobal: () => void;
jest.mock('services/GoogleBooksService');
describe('Detail Controller Test', () => {
beforeEach(() => {
setScope = jest.fn();
setGlobal = jest.fn();
GoogleBooksService.mockClear();
ctrl = new DetailCtrl({}, setScope, {}, setGlobal);
});
it('Test Get Book Success', () => {
const googleBooksService = GoogleBooksService.mock.instances[0];
googleBooksService.getBook = jest.fn(() =>
Promise.resolve(bookDetail.response));
const promise = ctrl.getBook('abc');
expect.assertions(2);
expect(googleBooksService.getBook).toHaveBeenCalledWith('abc', true);
return promise.then(() => {
expect(setScope).toHaveBeenCalledWith(bookDetail.response);
});
});
it('Test Get Book Failure', () => {
const googleBooksService = GoogleBooksService.mock.instances[0];
googleBooksService.getBook = jest.fn(() =>
Promise.reject('Error'));
const promise = ctrl.getBook('abc');
expect.assertions(2);
expect(googleBooksService.getBook).toHaveBeenCalledWith('abc', true);
return promise.then(() => {
expect(setScope).toHaveBeenCalledWith({ data: undefined });
});
});
});
|
pushkar8723/react-boilerplate
|
src/config/routes.ts
|
<reponame>pushkar8723/react-boilerplate
import { createRoute } from '@sparkx/react';
import { Error404 } from 'views/Error';
import { Welcome, WelcomeCtrl } from 'views/Welcome';
import { AccessType } from '../types';
/**
* This is the 'welcome' state. It is the default state (as defined by app.js) if no other state
* can be matched to the URL.
*/
const welcomeState = createRoute({
component: Welcome,
controller: WelcomeCtrl,
data: {
access: AccessType.UNAUTHENTICATED,
pageTitle: 'Welcome',
},
name: 'welcome',
url: '/welcome',
});
/**
* Error state. If the user is routed to an unregister route,
* then the usere is redirected to this page.
*/
const errorState = createRoute({
component: Error404,
data: {
access: AccessType.ALL,
pageTitle: 'Page Not Found',
},
name: '404',
url: '/notFound',
});
/**
* This is just a place holder for posts route.
* It will be lazy loaded when user navigates to any posts route.
*/
const booksFutureState = createRoute({
lazyLoad: () => import('views/Books'/* webpackChunkName: "books" */),
name: 'books.**',
url: '/books',
});
export default [welcomeState, booksFutureState, errorState];
|
pushkar8723/react-boilerplate
|
src/views/Books/BooksCtrl.ts
|
import { ControllerBase } from '@sparkx/core';
import { RoutingService } from '@sparkx/react';
import GoogleBooksService from 'services/GoogleBooksService';
import LocalStorageService from 'services/LocalStorageService';
import { IGlobal } from '../../types';
export interface IBooksState {
/**
* List of books
*/
books: IBookListItem[];
}
export interface IBookListItem {
/** Book authors */
authors: string[];
/** Book Identifier */
id: string;
/** Publisher */
publisher: string;
/** Subtitle for the book */
subtitle: string;
/** Standard size thumbnail for the book */
thumbnail?: string;
/** Book's title */
title: string;
}
/**
* Books Ctrl
*/
class BooksCtrl extends ControllerBase<IBooksState, IGlobal> {
/**
* Local Storage Service
*/
private _localStorageService = new LocalStorageService();
/**
* Google Book Service
*/
private _googleBooksService = new GoogleBooksService();
/**
* Routing Service
*/
private _routingService = new RoutingService();
/**
* Redirects to Books detailPage.
*
* @param bookName
*/
public loadBook = (bookName: string) => {
this._routingService.goTo('books.search');
return this._googleBooksService.searchBooks(bookName).then(
(resp) => {
const books = resp.data.items.map((book) => {
return {
authors: book.volumeInfo.authors,
id: book.id,
publisher: book.volumeInfo.publisher,
subtitle: book.volumeInfo.subtitle,
thumbnail: book.volumeInfo.imageLinks &&
book.volumeInfo.imageLinks.thumbnail,
title: book.volumeInfo.title,
};
});
this._setScope({ books });
},
);
}
/**
* Logs out the user.
*/
public logout = () => {
this._setGlobal({ auth: undefined });
this._localStorageService.remove('auth');
this._routingService.goTo('welcome');
}
}
export default BooksCtrl;
|
ThiagoCorrea98/desafio
|
src/components/Content.tsx
|
import '../styles/sidebar.scss';
import { GenreResponse, Movie } from "../model/movies";
import { MovieCard } from "./MovieCard";
interface ContentProps {
selectedGenre: GenreResponse;
movies: Movie[]; // array de filmes
}
export function Content({ movies, selectedGenre }: ContentProps) {
// Complete aqui
// cabeçalho contendo a categoria que será ser selecionada
return (
<div className="container">
<header>
<span className="category">
Categoria:<span> {selectedGenre.title}</span>
</span>
</header>
<main>
<div className="movies-list">
{movies.map((movie) => ( // mapeando a lista de filmes que deve ser exibida
<MovieCard
key={movie.imdbID}
title={movie.Title}
poster={movie.Poster}
runtime={movie.Runtime}
rating={movie.Ratings[0].Value}
/>
))}
</div>
</main>
</div>
);
}
|
vidyamohan5/Quiz-Task
|
src/app/app.component.ts
|
import { Component, OnInit, ViewChild } from '@angular/core';
import { Observable, from } from 'rxjs';
import { ModalDirective } from '../../node_modules/ngx-bootstrap';
import { QuestionClass } from './question-class';
import { ToastrService } from 'ngx-toastr';
import { FormGroup, FormBuilder } from '@angular/forms';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit {
isQuestionCardShow: boolean = false;
totalAnswered: number = 0;
rightAnswer: number;
questionObj = new QuestionClass();
@ViewChild('submitModal') submitModal: ModalDirective;
@ViewChild('addQuestionModal') addQuestionModal : ModalDirective;
@ViewChild('answerModal') answerModal : ModalDirective;
@ViewChild('questionForm') questionForm: any;
@ViewChild('questionTest') questionTest : any;
constructor( private toastr: ToastrService) { }
userInform: FormGroup;
answerArray = [];
main= true;
allQuestions: any = [{
"id": 1,
"question": "Who is the best cricketer in the world?",
"a": "<NAME>",
"b": "<NAME>",
"c": "<NAME>",
"d": "<NAME>",
"answer": "b"
},
];
allQuestions1: any = [{
"id": 1,
"question": "What are the colors in the Indian national flag?",
"a": "White",
"b": "Yellow",
"c": "Orange",
"d": "Green",
"answer": "a,c,d"
},
];
/**Method call on submit the test */
submitTest() {
this.rightAnswer = 0;
this.totalAnswered = 0;
for (let i = 0; i < this.allQuestions.length; i++) {
if ("selected" in this.allQuestions[i] && (this.allQuestions[i]["selected"] != null)) {
this.totalAnswered++;
if (this.allQuestions[i]["selected"] == this.allQuestions[i]["answer"]) {
this.rightAnswer++;
}
}
}
for (let i = 0; i < this.allQuestions1.length; i++) {
if ("selected" in this.allQuestions1[i] && (this.allQuestions1[i]["selected"] != null)) {
this.totalAnswered++;
if (this.allQuestions1[i]["selected"] == this.allQuestions1[i]["answer"]) {
this.rightAnswer++;
}
}
}
this.submitModal.show();
this.showHistory = true;
this.main = true;
}
date = new Date();
startQuiz() {
for (let i = 0; i < this.allQuestions.length; i++) {
if ("selected" in this.allQuestions[i]) {
delete this.allQuestions[i]["selected"];
}
}
for (let i = 0; i < this.allQuestions1.length; i++) {
if ("selected" in this.allQuestions1[i]) {
delete this.allQuestions1[i]["selected"];
}
}
this.questionTest.reset();
this.isQuestionCardShow = true;
}
HomePage() {
this.isQuestionCardShow = false;
}
checkAnswers(){
this.submitModal.hide();
this.answerModal.show();
}
showHistory = false;
showdetails = false;
hide(){
this.showHistory = true;
this.main = true;
}
History(){
this.showdetails = true;
}
ngOnInit() {
}
}
|
AsymptotikLabs/nodejs-bitpay-client
|
setup/BitPaySetup.ts
|
const fs = require('fs');
const request = require('request');
const BitPaySDK = require('../src/index');
const readline = require('readline');
let privateKeyPath = __dirname+'/../secure/private_key';
let ConfFilePath = __dirname+'/../secure/BitPay.config.json';
let keyUtils = new BitPaySDK.KeyUtils();
let keyPair;
let ecKey;
let environment;
let storeFile = true;
let apiUrl;
let merchantToken;
let merchantPairCode;
let payoutToken;
let payoutPairCode;
let keyPath = '';
let keyPlain = '';
let rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
let main = function () {
selectEnv();
};
let selectEnv = async () => {
try{
console.log("Select target environment:");
rl.question('Press T for testing or P for production: \n', async (answer) => {
switch(answer.toLowerCase()) {
case 't':
environment = 'Test';
await setEnv(environment);
selectCreateKey();
break;
case 'p':
environment = 'Prod';
await setEnv(environment);
selectCreateKey();
break;
default:
selectEnv();
}
});
} catch (e) {
console.log(e);
}
};
let setEnv = async (env) => {
if (env == 'Test') {
apiUrl = 'https://test.bitpay.com';
return;
}
apiUrl = 'https://bitpay.com';
};
let selectCreateKey = async () => {
try{
console.log("Enter your private key or its location");
rl.question('Or press Enter to generate a brand new key: ', async (answer) => {
switch (answer.toLowerCase()) {
case '':
await createNewKey();
break;
default:
await loadKey(answer);
break;
}
});
} catch (e) {
console.log(e);
}
};
let createNewKey = async () => {
try {
console.log("Generating private key... \n");
keyPair = keyUtils.generate_keypair();
ecKey = keyUtils.load_keypair(keyPair);
await sleep(2000);
console.log('Generated Private Key: ' + ecKey.getPrivate("hex"));
console.log('With Public Key: ' + ecKey.getPublic("hex") + '\n');
await storeKey();
} catch (e) {
console.log(e);
}
};
let loadKey = async (privateKey) => {
try {
if(fs.existsSync(privateKey)) {
console.log("Loading private key... \n");
await sleep(2000);
ecKey = keyUtils.load_keypair(fs.readFileSync(privateKey).toString().trim());
console.log('Loaded Private Key: ' + ecKey.getPrivate("hex"));
console.log('With Public Key: ' + keyUtils.getPublicKeyFromPrivateKey(ecKey));
console.log('From: ' + privateKey);
console.log("\n");
selectTokens();
}
else {
ecKey = keyUtils.load_keypair(privateKey);
console.log("Loading private key... \n");
await sleep(2000);
console.log('Loaded Private Key: ' + ecKey.getPrivate("hex"));
console.log('With Public Key: ' + keyUtils.getPublicKeyFromPrivateKey(ecKey));
console.log('From: ' + privateKey);
console.log("\n");
selectTokens();
}
} catch (e) {
console.log(e);
}
};
let storeKey = async () => {
try {
if (!fs.existsSync(__dirname+'/../secure')){
fs.mkdirSync(__dirname+'/../secure');
}
console.log("Select the way you want to store your private key:");
rl.question('Press F for storing in a text file or T for plain text in your config file: ', async (answer) => {
switch (answer.toLowerCase()) {
case 'f':
storeFile = true;
keyPath = privateKeyPath + '_' + environment.toLowerCase() + '.key';
console.log("Saving private key... \n");
sleep(500);
fs.writeFile(privateKeyPath + '_' + environment.toLowerCase() + '.key', ecKey.getPrivate("hex"), {mode: 0o755}, function (err) {
if (err) throw err;
console.log('Private key saved in file: ' + keyPath + '\n');
});
await sleep(1000);
selectTokens();
break;
case 't':
storeFile = false;
keyPlain = ecKey.getPrivate("hex");
console.log("Saving private key... \n");
await sleep(1000);
selectTokens();
break;
default:
storeKey();
}
});
} catch (e) {
console.log(e);
}
};
let selectTokens = async () => {
try{
console.log("Select the tokens that you would like to request:");
rl.question('Press M for merchant, P for payout, or B for both: \n', async (answer) => {
switch(answer.toLowerCase()) {
case 'm':
case 'p':
case 'b':
console.log("Requesting tokens... \n");
await sleep(500);
await requestTokens(answer);
break;
default:
selectTokens();
}
});
} catch (e) {
console.log(e);
}
};
let requestTokens = async (option) => {
try{
let reqMerchant = false;
let reqPayout = false;
switch (option.toLowerCase()) {
case 'm':
reqMerchant = true;
reqPayout = false;
break;
case 'p':
reqMerchant = false;
reqPayout = true;
break;
case 'b':
reqMerchant = true;
reqPayout = true;
break;
}
let sin = keyUtils.get_sin_from_key(ecKey);
let headers = {
"x-accept-version": "2.0.0",
"Content-type": "application/json"
};
if (reqMerchant) {
console.log("Requesting Merchant token... \n");
let facade = 'merchant';
let postData = {id: sin,facade: facade};
let options = {
url: apiUrl + '/tokens',
method: 'POST',
body: postData,
headers: headers,
json: true
};
request(options, function (error, response, body) {
let jsonResponse = JSON.parse(JSON.stringify(body.data[0]));
merchantToken = jsonResponse['token'];
merchantPairCode = jsonResponse['pairingCode'];
});
await sleep(2000);
}
if (reqPayout) {
console.log("Requesting Payout token... \n");
let facade = 'payout';
let postData = {id: sin,facade: facade};
let options = {
url: apiUrl + '/tokens',
method: 'POST',
body: postData,
headers: headers,
json: true
};
request(options, function (error, response, body) {
let jsonResponse = JSON.parse(JSON.stringify(body.data[0]));
payoutToken = jsonResponse['token'];
payoutPairCode = jsonResponse['pairingCode'];
});
await sleep(2000);
}
await updateConfigFile();
} catch (e) {
console.log(e);
}
};
let updateConfigFile = async () => {
// console.log(merchantToken);
// console.log(payoutToken);
let confObj;
if (environment == 'Test') {
confObj = {
'BitPayConfiguration': {
"Environment": "Test",
"EnvConfig": {
"Test": {
"PrivateKeyPath": keyPath,
"PrivateKey": keyPlain,
"ApiTokens": {
"merchant": merchantToken,
"payout": payoutToken
}
}
}
}
};
} else {
confObj = {
'BitPayConfiguration': {
"Environment": "Prod",
"EnvConfig": {
"Prod": {
"PrivateKeyPath": keyPath,
"PrivateKey": keyPlain,
"ApiTokens": {
"merchant": merchantToken,
"payout": payoutToken
}
}
}
}
};
}
confObj['BitPayConfiguration']['EnvConfig'][environment] = {
"PrivateKeyPath" : keyPath,
"PrivateKey" : keyPlain,
"ApiTokens" : {
"merchant" : merchantToken,
"payout": payoutToken
}
};
fs.writeFile(ConfFilePath, JSON.stringify(confObj, null, 4), function (err) {
if (err) throw err;
console.log('Generated configuration file');
console.log('And saved in file: ' + ConfFilePath + '\n');
});
await sleep(5000);
console.log('Configuration generated successfully! \n');
console.log("To complete your setup, Go to " + apiUrl + "/dashboard/merchant/api-tokens and pair this client with your merchant account using the pairing codes:");
if (merchantToken) {
console.log(merchantPairCode + " for the Merchant facade.");
}
if (payoutToken) {
console.log(payoutPairCode + " for the Payout facade ONLY if you have requested access for this role.");
}
process.exit();
};
function sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
main();
|
AsymptotikLabs/nodejs-bitpay-client
|
src/Tokens.ts
|
<gh_stars>10-100
export interface Tokens {
merchant: string | null;
payout: string | null;
}
|
Mammut-FE/vscode-hive-languageservice
|
src/services/languageFacts.ts
|
<reponame>Mammut-FE/vscode-hive-languageservice<gh_stars>1-10
import { ICol, ICteTable } from '@mammut-fe/hive-parser';
import { CompletionItemKind } from 'vscode-languageserver-types';
import * as hiveData from '../data/hive';
import { getDatabaseService } from './databaseService';
const databaseService = getDatabaseService();
export interface Value {
name: string;
description: string;
kind: CompletionItemKind;
detail?: string;
}
export interface IEntry {
name: string;
restrictions: string[];
description: string;
values: Value[];
detail?: string;
}
class ValueImpl implements Value {
constructor(public data: any) {
}
get name(): string {
return this.data.name;
}
get description(): string {
return this.data.desc || hiveData.descriptions[this.data.name];
}
get kind(): CompletionItemKind {
return this.data.kind || CompletionItemKind.Text;
}
get needComma(): boolean {
return !!this.data.needComma;
}
get detail(): string {
return this.data.detail;
}
}
class EntryImpl implements IEntry {
constructor(public data: any) {
}
get name(): string {
return this.data.name;
}
get description(): string {
return this.data.desc || hiveData.descriptions[this.data.name];
}
get restrictions(): string[] {
if (this.data.restrictions) {
return (this.data.restrictions as string).split(',').map(s => s.trim());
} else {
return [];
}
}
get values(): Value[] {
if (!this.data.values) {
return [];
}
if (!Array.isArray(this.data.values)) {
return [new ValueImpl(this.data.values.value)];
}
return this.data.values.map(v => new ValueImpl(v));
}
get detail(): string {
return this.data.detail;
}
}
const keywords = hiveData.data.keywords;
let keywordsList: IEntry[];
export function getKeywordEntryList() {
if (!keywordsList) {
keywordsList = [];
for (let i = 0; i < keywords.length; i++) {
let rawEntry = keywords[i];
rawEntry.name = rawEntry.name.toLowerCase();
keywordsList.push(new EntryImpl(rawEntry));
}
}
return keywordsList;
}
const builtInFunctions = hiveData.data.builtInFunctions;
let builtInFunctionEntryList: IEntry[];
export function getFunctionsEntryList(): IEntry[] {
if (!builtInFunctionEntryList) {
builtInFunctionEntryList = [];
for (let i = 0; i < builtInFunctions.length; i++) {
let rawEntry = builtInFunctions[i];
rawEntry.name += '()';
builtInFunctionEntryList.push(new EntryImpl(rawEntry));
}
}
return builtInFunctionEntryList;
}
const useStmtList = hiveData.data.use;
let useStmtEntryList: IEntry[];
export function getUseStmtEntryList() {
if (!useStmtEntryList) {
useStmtEntryList = [];
for (let i = 0; i < useStmtList.length; i++) {
let rawEntry = useStmtList[i];
useStmtEntryList.push(new EntryImpl(rawEntry));
}
}
return useStmtEntryList;
}
const selectStmtList = hiveData.data.select;
let selectStmtEntryList: IEntry[];
export function getSelectStmtEntryList() {
if (!selectStmtEntryList) {
selectStmtEntryList = [];
for (let i = 0; i < selectStmtList.length; i++) {
let rawEntry = selectStmtList[i];
selectStmtEntryList.push(new EntryImpl(rawEntry));
}
}
return selectStmtEntryList;
}
export function getDatabaseEntryList(): IEntry[] {
return databaseService.getDatabaseList().map(db => {
return new EntryImpl({
name: db.name,
detail: 'database'
});
});
}
export function getTableEntryList(db: string): IEntry[] {
return databaseService.getTables(db).map(table => {
return new EntryImpl({
name: table.name,
detail: 'table'
});
});
}
export function getColumnEntryList(dbName: string, tableName: string, columns: ICol[] = []): IEntry[] {
const cache = {};
let isAll = columns.length === 0;
columns.forEach(col => {
if (col.name === '*') {
isAll = true;
}
cache[col.name] = true;
});
const columnsList = databaseService
.getColumns(dbName, tableName)
.filter(column => {
return isAll || cache[column.name];
})
.map(column => {
return new EntryImpl({
name: column.name,
detail: 'column'
});
});
columnsList.push(new EntryImpl({ name: '*', detail: 'keyword' }));
return columnsList;
}
export function getCteTableEntryList(cteTables: ICteTable[]): IEntry[] {
return cteTables.map(cteTable => {
return new EntryImpl({
name: cteTable.name,
detail: 'table'
});
});
}
export function getEntryDescription(entry: { description: string; data?: any }): string | null {
if (!entry.description || entry.description === '') {
return null;
}
let desc: string = '';
desc += entry.description;
if (entry.data && entry.data.syntax) {
desc += `\n\nSyntax: ${entry.data.syntax}`;
}
return desc;
}
|
Mammut-FE/vscode-hive-languageservice
|
src/data/hive.ts
|
import { builtInFunctions, keywords } from '@mammut-fe/hive-data';
import { CompletionItemKind } from 'vscode-languageserver-types';
export const data: any = {
use: [
{
name: 'use',
desc: 'USE sets the current database for all subsequent HiveQL statements.',
restriction: 'string',
values: [
{
name: 'default',
desc: 'HiveQL default database.',
kind: CompletionItemKind.Keyword,
detail: 'keyword'
}
]
}
],
select: [
{
name: 'select',
decs: '',
restriction: 'function',
values: [
{
name: 'current_database()',
desc: 'HiveQL default database.',
kind: CompletionItemKind.Keyword,
detail: 'function'
},
{
name: '*',
kind: CompletionItemKind.Value,
detail: 'keyword'
}
]
}
],
builtInFunctions,
keywords
};
export const descriptions: any = {};
|
Mammut-FE/vscode-hive-languageservice
|
tests/completion.test.ts
|
import {
CompletionItemKind,
CompletionList,
InsertTextFormat,
Position,
TextDocument
} from 'vscode-languageserver-types';
import * as hiveData from '../src/data/hive';
import * as hiveLanguageService from '../src/hiveLanguageService';
export interface ItemDescription {
label: string;
detail?: string;
documentation?: string;
kind?: CompletionItemKind;
insertTextFormat?: InsertTextFormat;
resultText?: string;
notAvailable?: boolean;
}
function asPromise<T>(result: T): Promise<T> {
return Promise.resolve(result);
}
export let assertCompletion = function(
completions: CompletionList,
expected: ItemDescription,
document: TextDocument,
offset: number
) {
let matches = completions.items.filter(completion => {
return completion.label === expected.label;
});
let match = matches[0];
if (expected.detail) {
expect(match.detail).toEqual(expected.detail);
}
if (expected.documentation) {
expect(match.documentation).toEqual(expected.documentation);
}
if (expected.kind) {
expect(match.kind).toEqual(expected.kind);
}
if (expected.resultText) {
expect(TextDocument.applyEdits(document, [match.textEdit])).toEqual(expected.resultText);
}
if (expected.insertTextFormat) {
expect(match.insertTextFormat).toEqual(expected.insertTextFormat);
}
};
describe('Hive - Completion', () => {
let testCompletionFor = function(value: string, expected: { count?: number; items?: ItemDescription[] }) {
let offset = value.indexOf('|');
value = value.substr(0, offset) + value.substr(offset + 1);
let ls = hiveLanguageService.getLanguageService();
let document = TextDocument.create('test://test/test.hive', 'hive', 0, value);
let position = Position.create(0, offset);
let text = document.getText();
let wordAtOffset = text[offset - 1];
if (wordAtOffset === '.' || wordAtOffset === ',') {
text = text.substr(0, offset) + 'PLACEHOLDER' + text.substr(offset);
}
let jsonDoc = ls.parseProgram(text);
let list = ls.doComplete(document, position, jsonDoc);
if (typeof expected.count === 'number') {
expect(list.items.length).toEqual(expected.count);
}
if (expected.items) {
for (let item of expected.items) {
assertCompletion(list, item, document, offset);
}
}
};
test('top level', function(): any {
const MOCK_DB_LENGTH = 2;
const count = hiveData.data.keywords.length + hiveData.data.builtInFunctions.length + MOCK_DB_LENGTH;
testCompletionFor('u|', { count });
testCompletionFor(' |', { count });
});
test('use', function(): any {
testCompletionFor('use |', {
items: [
{
label: 'school',
resultText: 'use school',
detail: 'database'
},
{
label: 'library',
resultText: 'use library',
detail: 'database'
},
{
label: 'default',
resultText: 'use default',
detail: 'keyword'
}
]
});
testCompletionFor('use |;', {
items: [
{
label: 'school',
resultText: 'use school;',
detail: 'database'
},
{
label: 'library',
resultText: 'use library;',
detail: 'database'
},
{
label: 'default',
resultText: 'use default;',
detail: 'keyword'
}
]
});
});
test('Select: from clause', function(): any {
testCompletionFor('select * from |', {
items: [
{
label: 'school',
resultText: 'select * from school',
detail: 'database'
},
{
label: 'library',
resultText: 'select * from library',
detail: 'database'
}
]
});
testCompletionFor('use school; select * from |', {
items: [
{
label: 'student',
resultText: 'use school; select * from student',
detail: 'table'
},
{
label: 'course',
resultText: 'use school; select * from course',
detail: 'table'
},
{
label: 'school',
resultText: 'use school; select * from school',
detail: 'database'
},
{
label: 'library',
resultText: 'use school; select * from library',
detail: 'database'
}
]
});
testCompletionFor('select * from school.|', {
items: [
{
label: 'student',
resultText: 'select * from school.student',
detail: 'table'
},
{
label: 'course',
resultText: 'select * from school.course',
detail: 'table'
}
]
});
});
test('Select: select_list clause', function(): any {
testCompletionFor('SELECT | FROM school.student', {
items: [
{
label: 'name',
resultText: 'SELECT name FROM school.student',
detail: 'column'
},
{
label: 'id',
resultText: 'SELECT id FROM school.student',
detail: 'column'
},
{
label: '*',
resultText: 'SELECT * FROM school.student',
detail: 'keyword'
}
]
});
testCompletionFor('use school; select | from student', {
items: [
{
label: 'name',
resultText: 'use school; select name from student',
detail: 'column'
},
{
label: 'id',
resultText: 'use school; select id from student',
detail: 'column'
},
{
label: '*',
resultText: 'use school; select * from student',
detail: 'keyword'
}
]
});
testCompletionFor('SELECT id, | FROM school.student', {
items: [
{
label: 'name',
resultText: 'SELECT id, name FROM school.student',
detail: 'column'
}
]
});
});
test('Select: join clause', function() {
testCompletionFor('SELECT * FROM school.student t1, |', {
items: [
{
label: 'library',
resultText: 'SELECT * FROM school.student t1, library',
detail: 'database'
}
]
});
testCompletionFor('SELECT * FROM school.student t1, library.|', {
items: [
{
label: 'user',
resultText: 'SELECT * FROM school.student t1, library.user',
detail: 'table'
}
]
});
testCompletionFor('SELECT * FROM school.student JOIN |', {
items: [
{
label: 'school',
resultText: 'SELECT * FROM school.student JOIN school',
detail: 'database'
}
]
});
testCompletionFor('SELECT * FROM school.student JOIN school.|', {
items: [
{
label: 'student',
resultText: 'SELECT * FROM school.student JOIN school.student',
detail: 'table'
}
]
});
testCompletionFor('SELECT * FROM school.student LEFT JOIN |', {
items: [
{
label: 'school',
resultText: 'SELECT * FROM school.student LEFT JOIN school',
detail: 'database'
}
]
});
testCompletionFor('SELECT * FROM school.student LEFT JOIN school.|', {
items: [
{
label: 'course',
resultText: 'SELECT * FROM school.student LEFT JOIN school.course',
detail: 'table'
}
]
});
});
test('Select: select_list clause with from clause alias', function(): any {
testCompletionFor('SELECT s.| FROM school.student s', {
items: [
{
label: 'name',
resultText: 'SELECT s.name FROM school.student s',
detail: 'column'
},
{
label: 'id',
resultText: 'SELECT s.id FROM school.student s',
detail: 'column'
},
{
label: '*',
resultText: 'SELECT s.* FROM school.student s',
detail: 'keyword'
}
]
});
testCompletionFor('SELECT s.name, s.| FROM school.student s', {
items: [
{
label: 'id',
resultText: 'SELECT s.name, s.id FROM school.student s',
detail: 'column'
},
{
label: '*',
resultText: 'SELECT s.name, s.* FROM school.student s',
detail: 'keyword'
}
]
});
testCompletionFor('SELECT s.name, c.| FROM school.student s, school.course c', {
items: [
{
label: 'id',
resultText: 'SELECT s.name, c.id FROM school.student s, school.course c',
detail: 'column'
},
{
label: '*',
resultText: 'SELECT s.name, c.* FROM school.student s, school.course c',
detail: 'keyword'
}
]
});
testCompletionFor('use library; SELECT user.| FROM user JOIN book ON user.id = book.id', {
items: [
{
label: 'userid',
resultText: 'use library; SELECT user.userid FROM user JOIN book ON user.id = book.id',
detail: 'column'
},
{
label: '*',
resultText: 'use library; SELECT user.* FROM user JOIN book ON user.id = book.id',
detail: 'keyword'
}
]
});
});
test('Select: cte select', function(): any {
testCompletionFor('with s as (select * from school.student) select * from |', {
items: [
{
label: 's',
resultText: 'with s as (select * from school.student) select * from s',
detail: 'table'
},
{
label: 'school',
resultText: 'with s as (select * from school.student) select * from school',
detail: 'database'
}
]
});
testCompletionFor('with s as (select * from school.student) select * from school.|', {
items: [
{
label: 'student',
resultText: 'with s as (select * from school.student) select * from school.student',
detail: 'table'
}
]
});
testCompletionFor('with s as (select * from school.student) select | from s', {
items: [
{
label: 'name',
resultText: 'with s as (select * from school.student) select name from s',
detail: 'column'
},
{
label: '*',
resultText: 'with s as (select * from school.student) select * from s',
detail: 'keyword'
}
]
});
testCompletionFor('with s as (select id, name from school.student) select | from s', {
items: [
{
label: 'id',
resultText: 'with s as (select id, name from school.student) select id from s',
detail: 'column'
},
{
label: 'name',
resultText: 'with s as (select id, name from school.student) select name from s',
detail: 'column'
},
{
label: '*',
resultText: 'with s as (select id, name from school.student) select * from s',
detail: 'keyword'
}
]
});
});
test('Other', function(): any {
testCompletionFor('drop table |', {
items: [
{
label: 'school',
resultText: 'drop table school',
detail: 'database'
}
]
});
testCompletionFor('with t as (select * from |)', {
items: [
{
label: 'school',
resultText: 'with t as (select * from school)',
detail: 'database'
}
]
});
testCompletionFor('drop table school.|', {
items: [
{
label: 'student',
resultText: 'drop table school.student',
detail: 'table'
}
]
});
});
});
|
Mammut-FE/vscode-hive-languageservice
|
src/services/databaseService.ts
|
import { IColumn, IDatabase, ITable } from '../hiveLanguageTypes';
let dbs: IDatabase[] = [
{
name: 'school',
tables: [
{
name: 'student',
columns: [{
name: 'id'
}, {
name: 'sex'
}, {
name: 'age'
}, {
name: 'name'
}]
},
{
name: 'course',
columns: [{
name: 'id'
}, {
name: 'name'
}, {
name: 'hour'
}, {
name: 'score'
}]
}
]
},
{
name: 'library',
tables: [
{
name: 'user',
columns: [
{ name: 'userid' },
{ name: 'password' }
]
},
{
name: 'book',
columns: [
{ name: 'bookid' },
{ name: 'bookname' }
]
}
]
}
];
let databaseServiceImpl: DataBaseServices = null;
export class DataBaseServices {
public getDatabaseList(): IDatabase[] {
return dbs.map(db => db);
}
public getTables(db: string): ITable[] {
const database = this.findDatabase(db);
if (database) {
return database.tables.map(table => table);
}
return [];
}
public getColumns(dbName: string, tableName: string): IColumn[] {
const table = this.findTable(dbName, tableName);
if (table) {
return table.columns.map(column => column);
}
return [];
}
public findDatabase(dbName: string): IDatabase | null {
let result = dbs.filter(db => db.name === dbName);
return result.length > 0 ? result[0] : null;
}
public findTable(dbName: string, tableName: string): ITable | null {
const db = this.findDatabase(dbName);
if (!db) return null;
const result = db.tables.filter(table => table.name === tableName);
return result.length > 0 ? result[0] : null;
}
public findColumn(dbName: string, tableName: string, colName: string): IColumn | null {
const table = this.findTable(dbName, tableName);
if (!table) return null;
const result = table.columns.filter(col => col.name === colName);
return result.length > 0 ? result[0] : null;
}
}
export function updateDatabase(database: IDatabase[]): void {
dbs = database;
}
export function getDatabaseService() {
if (!databaseServiceImpl) {
databaseServiceImpl = new DataBaseServices();
}
return databaseServiceImpl;
}
|
Mammut-FE/vscode-hive-languageservice
|
src/hiveLanguageService.ts
|
import { CompletionList, Diagnostic, Position, TextDocument } from 'vscode-languageserver-types';
import { Parser, Program } from '@mammut-fe/hive-parser';
import { HiveCompletion } from './services/hiveCompletion';
export interface LanguageService {
doValidation(text: string): Promise<Diagnostic[]>;
doComplete(document: TextDocument, position: Position, program: Program): CompletionList;
parseProgram(input: string): Program;
}
function createFacade(parser: Parser, completion: HiveCompletion): LanguageService {
return {
doComplete: completion.doComplete.bind(completion),
doValidation: null,
parseProgram: parser.parse.bind(parser)
};
}
export function getLanguageService(): LanguageService {
return createFacade(new Parser(), new HiveCompletion());
}
|
Mammut-FE/vscode-hive-languageservice
|
src/hiveLanguageTypes.ts
|
export interface ICompletionParticipant {
}
import { Range, TextEdit, Position } from 'vscode-languageserver-types';
export { Range, TextEdit, Position };
export interface IDatabaseServices {
getDatabaseList(): IDatabase[];
getTables(db: string): ITable[];
getColumns(db: string, table: string): IColumn[];
findDatabase(db: string): IDatabase | null;
findTable(db: string, table: string): ITable | null;
findColumn(db: string, table: string, col: string): IColumn | null;
}
export interface IDatabase {
name: string;
tables: ITable[];
[key: string]: any;
}
export interface ITable {
name: string;
columns: IColumn[];
[key: string]: any;
}
export interface IColumn {
name: string;
[key: string]: any;
}
|
Mammut-FE/vscode-hive-languageservice
|
src/services/hiveCompletion.ts
|
<reponame>Mammut-FE/vscode-hive-languageservice
import {
Expr,
getPath,
ICol,
Keyword,
Node,
NodeType,
Program,
Select,
SubSelect,
TableName,
Use
} from '@mammut-fe/hive-parser';
import {
CompletionItem,
CompletionItemKind,
CompletionList,
InsertTextFormat,
Position,
Range,
TextDocument,
TextEdit
} from 'vscode-languageserver-types';
import { ICompletionParticipant, IDatabase } from '../hiveLanguageTypes';
import { updateDatabase } from './databaseService';
import * as languageFacts from './languageFacts';
const SnippetFormat = InsertTextFormat.Snippet;
export class HiveCompletion {
position: Position;
offset: number;
currentWord: string;
textDocument: TextDocument;
program: Program;
defaultReplaceRange: Range;
nodePath: Node[];
completionParticipants: ICompletionParticipant[] = [];
private getCompletionRangeFromNode(existingNode: Node): Range {
if (existingNode && existingNode.offset <= this.offset) {
const index = existingNode.getText().indexOf('.');
let end, start;
if (index > -1) {
start = this.textDocument.positionAt(existingNode.offset + index + 1);
end = start;
} else {
start = this.textDocument.positionAt(existingNode.offset + 1);
end = existingNode.end !== -1 ? this.textDocument.positionAt(existingNode.end) : this.position;
}
return Range.create(start, end);
}
return this.defaultReplaceRange;
}
private findBeforeExprNode(node: Expr): Node {
let offset = node.offset - 1;
let prev = this.program.findChildAtOffset(offset, true);
while (prev.type === NodeType.Expr) {
offset = prev.offset - 1;
prev = this.program.findChildAtOffset(offset, true);
}
return prev;
}
private findBeforeSemicolonExpr(node: Node): Node {
let offset = node.offset - 1;
let prev = this.program.findChildAtOffset(offset, true);
while (prev.type !== NodeType.Expr) {
offset = prev.offset - 1;
prev = this.program.findChildAtOffset(offset, true);
}
return prev;
}
private getCurrentDatabase(offset: number): string {
const block = this.program.getBlockNode();
const useNodes = block.getChildren().filter(node => {
return node.type === NodeType.Use;
});
for (let i = useNodes.length - 1; i >= 0; i--) {
let useNode = useNodes[i];
if (offset > useNode.end) {
return (useNode as Use).getUseDbName();
}
}
return null;
}
private getCurrentTableInfo(node: Node, str: string) {
let [dbName, tableName] = str.split('.');
let columns: ICol[] = [];
const select = node.findParent(NodeType.Select) as Select;
const cteTables = select.getCteTables();
if (cteTables.length > 0) {
const rawTale = cteTables.filter(cteTable => {
return cteTable.name === dbName;
})[0];
if (rawTale) {
const { origin } = rawTale;
const fromTables = origin.getFromTables();
if (fromTables.length === 1) {
[dbName, tableName] = (fromTables[0].rawTable as string).split('.');
}
columns = origin.getSelectCols();
}
}
if (tableName === undefined) {
tableName = dbName;
dbName = this.getCurrentDatabase(node.findParent(NodeType.Select).offset);
}
return {
dbName,
tableName,
columns
};
}
public doComplete(
document: TextDocument,
position: Position,
program: Program,
databases?: IDatabase[]
): CompletionList {
this.offset = document.offsetAt(position);
this.position = position;
this.currentWord = getCurrentWord(document, this.offset);
this.defaultReplaceRange = Range.create(
Position.create(this.position.line, this.position.character - this.currentWord.length),
this.position
);
this.textDocument = document;
this.program = program;
if (databases) {
updateDatabase(databases);
}
try {
let result: CompletionList = { isIncomplete: false, items: [] };
this.nodePath = getPath(this.program, this.offset);
for (let i = this.nodePath.length - 1; i >= 0; i--) {
let node = this.nodePath[i];
if (node.type === NodeType.Use) {
} else if (node.type === NodeType.SubSelect) {
this.getCompletionsForSelectList(node, result);
} else if (node.type === NodeType.SelectList) {
this.getCompletionsForSelectList(node.findParent(NodeType.SubSelect), result);
} else if (node.type === NodeType.TableName) {
this.getCompletionsForFrom(node, result);
} else if (node.type === NodeType.Expr) {
this.getCompletionsForExpr(node as Expr, result);
} else if (node.type === NodeType.Keyword) {
this.getCompletionsForKeywords(node as Keyword, result);
} else if (node.type === NodeType.Semicolon) {
this.getCompletionsSemicolon(node, result);
} else if (node.parent === null) {
this.getCompletionsForTopLevel(result);
} else {
continue;
}
if (result.items.length > 0 || this.offset > node.offset) {
return this.finalize(result);
}
}
this.getCompletionForProgram(result);
return this.finalize(result);
} finally {
// don't hold on any state, clear symbolContext
this.position = null;
this.currentWord = null;
this.textDocument = null;
this.program = null;
this.defaultReplaceRange = null;
this.nodePath = null;
}
}
private finalize(result: CompletionList): CompletionList {
let needSortText = result.items.some(i => !!i.sortText);
if (needSortText) {
for (let i of result.items) {
if (!i.sortText) {
i.sortText = 'd';
}
}
}
return result;
}
public getValueEnumProposals(
entry: languageFacts.IEntry,
existingNode: Node,
result: CompletionList
): CompletionList {
if (entry.values) {
for (let value of entry.values) {
let insertString = value.name;
let insertTextFormat;
if (insertString.endsWith(')')) {
let from = insertString.lastIndexOf('(');
if (from !== -1) {
insertString = insertString.substr(0, from) + '($1)';
insertTextFormat = SnippetFormat;
}
}
let item: CompletionItem = {
label: value.name,
documentation: languageFacts.getEntryDescription(value),
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(existingNode), insertString),
kind: value.kind,
insertTextFormat,
sortText: 'e',
detail: value.detail
};
result.items.push(item);
}
}
return result;
}
public getCompletionForProgram(result: CompletionList): CompletionList {
if (this.program === null) {
return this.getCompletionsForTopLevel(result);
}
let node = this.program.findFirstChildBeforeOffset(this.offset);
let prev: Node;
if (!node) {
return this.getCompletionsForTopLevel(result);
}
while (node) {
prev = node;
node = node.findFirstChildBeforeOffset(this.offset);
}
if (prev instanceof Expr) {
this.getCompletionsForExpr(prev, result);
}
if (prev.type === NodeType.ID) {
this.getCompletionsForIdentifier(prev, result);
}
return result;
}
public getCompletionsForTopLevel(result: CompletionList): CompletionList {
if (this.currentWord.endsWith('.')) {
const [dbName] = this.currentWord.split('.');
for (let entry of languageFacts.getTableEntryList(dbName)) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Text,
textEdit: TextEdit.replace(Range.create(this.defaultReplaceRange.end, this.defaultReplaceRange.end), entry.name),
detail: entry.detail
});
}
} else {
this.getCompletionsForKeywords(null, result);
this.getCompletionsForFunctions(result);
this.getCompletionsForDatabase(null, result, 'z');
}
return result;
}
public getCompletionsForFunctions(result: CompletionList): CompletionList {
for (let entry of languageFacts.getFunctionsEntryList()) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Function,
detail: 'function',
sortText: 'g'
});
}
return result;
}
public getCompletionsForKeywords(node: Node, result: CompletionList): CompletionList {
if (node) {
switch (node.getText().toLowerCase()) {
case 'select':
this.getCompletionsForSelectList(node, result);
break;
}
} else {
for (let entry of languageFacts.getKeywordEntryList()) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Keyword,
detail: 'keyword',
sortText: 'f'
});
}
}
return result;
}
public getCompletionsForExpr(node: Expr, result: CompletionList): CompletionList {
const exprText = node.getText().toLowerCase();
if (exprText.indexOf('.') !== -1) {
if (node.parent.type === NodeType.SelectListItem) {
const [aliasName] = exprText.split('.');
this.getCompletionsForSelectList(node, result, aliasName);
} else {
const [dbName] = exprText.split('.');
this.getCompletionsForTable(node, result, dbName, 'a');
}
} else {
switch (node.getText().toLowerCase()) {
case 'use':
this.getCompletionsForUse(node, result);
break;
case 'from':
this.getCompletionsForFrom(node, result);
break;
case 'select':
this.getCompletionsForSelectList(node, result);
break;
case 'join':
this.getCompletionsForJoin(node, result);
break;
default:
this.getCompletionsForTopLevel(result);
}
}
return result;
}
public getCompletionsForUse(node: Node, result: CompletionList): CompletionList {
for (let entry of languageFacts.getUseStmtEntryList()) {
this.getValueEnumProposals(entry, null, result);
}
this.getCompletionsForDatabase(null, result, 'a');
return result;
}
public getCompletionsForFrom(node: Node, result: CompletionList): CompletionList {
if (node.type === NodeType.TableName) {
/**
* select * from db.|
* 优先提示 db 对应的表
*/
let [db] = (node as TableName).getTableName().split('.');
this.getCompletionsForTable(node, result, db, 'a');
} else if (node.type === NodeType.Expr) {
/**
* select * from |
* 依次提示 cte_table, use db, 所有的 db
*/
const prev = this.findBeforeExprNode(node);
const selectNode = prev.findParent(NodeType.Select) as Select;
if (selectNode) {
this.getTableCompletionList(selectNode, result);
}
}
return result;
}
public getCompletionsForSelectList(node: Node, result: CompletionList, tableAliasName?: string): CompletionList {
if (node instanceof Expr) {
if (tableAliasName) {
const subSelect = node.findParent(NodeType.SubSelect) as SubSelect;
const fromTables = subSelect.getFromTables();
const { rawTable } = fromTables.filter(({ rawTable, aliasName }) => {
return aliasName ? aliasName === tableAliasName : rawTable === tableAliasName;
})[0];
if (rawTable) {
const { dbName, tableName, columns } = this.getCurrentTableInfo(node, rawTable as string);
for (let entry of languageFacts.getColumnEntryList(dbName, tableName, columns)) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Text,
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(node), entry.name),
detail: entry.detail,
sortText: 'a'
});
}
}
}
for (let entry of languageFacts.getSelectStmtEntryList()) {
this.getValueEnumProposals(entry, null, result);
}
} else if (node instanceof Keyword || node instanceof SubSelect) {
const subSelect = node.findParent(NodeType.SubSelect) as SubSelect;
const selectCols = subSelect.getSelectCols();
const fromTable = selectCols.filter(col => {
return col.name.toLowerCase() === 'from';
});
if (fromTable.length > 0) {
const { dbName, tableName, columns } = this.getCurrentTableInfo(node, fromTable[0].aliasName);
for (let entry of languageFacts.getColumnEntryList(dbName, tableName, columns)) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Text,
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(null), entry.name),
detail: entry.detail,
sortText: 'a'
});
}
}
}
return result;
}
public getCompletionsForIdentifier(node: Node, result: CompletionList): CompletionList {
if (node.findParent(NodeType.FromClause)) {
this.getCompletionsForJoin(node, result);
}
return result;
}
public getCompletionsForJoin(node: Node, result: CompletionList): CompletionList {
let selectNode;
if (node.type === NodeType.ID) {
selectNode = node.findParent(NodeType.Select) as Select;
} else if (node.type === NodeType.Expr) {
const prev = this.findBeforeExprNode(node);
selectNode = prev.findParent(NodeType.Select) as Select;
}
if (selectNode) {
this.getTableCompletionList(selectNode, result);
}
return result;
}
public getTableCompletionList(node: Select, result: CompletionList): CompletionList {
const cteTables = node.getCteTables();
for (let entry of languageFacts.getCteTableEntryList(cteTables)) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Variable,
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(null), entry.name),
detail: entry.detail,
sortText: 'a'
});
}
const currentDatabase = this.getCurrentDatabase(node.offset);
if (currentDatabase) {
this.getCompletionsForTable(null, result, currentDatabase, 'b');
}
this.getCompletionsForDatabase(null, result, 'c');
return result;
}
private getCompletionsSemicolon(node: Node, result: CompletionList): CompletionList {
const prevNode = this.findBeforeSemicolonExpr(node);
this.getCompletionsForExpr(prevNode as Expr, result);
return result;
}
private getCompletionsForDatabase(node: Node, result: CompletionList, sortText = 'd') {
for (let entry of languageFacts.getDatabaseEntryList()) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Text,
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(node), entry.name),
detail: entry.detail,
sortText: sortText
});
}
}
private getCompletionsForTable(node: Node, result: CompletionList, databaseName: string, sortText = 'd') {
for (let entry of languageFacts.getTableEntryList(databaseName)) {
result.items.push({
label: entry.name,
documentation: languageFacts.getEntryDescription(entry),
kind: CompletionItemKind.Text,
textEdit: TextEdit.replace(this.getCompletionRangeFromNode(node), entry.name),
detail: entry.detail,
sortText
});
}
}
}
function getCurrentWord(document: TextDocument, offset: number) {
let i = offset - 1;
let text = document.getText();
while (i >= 0 && ' \t\n\r":{[()]},*>+'.indexOf(text.charAt(i)) === -1) {
i--;
}
return text.substring(i + 1, offset);
}
|
prantlf/oscript-parser
|
pkg/walker/dist/index.d.ts
|
<reponame>prantlf/oscript-parser
import { Node, SourceLocation } from 'oscript-parser'
export type SimplePreCallback<TState> = (
node: Node,
state: TState,
parent: Node | null
) => boolean | any
export type SimplePostCallback<TState> = (
node: Node,
state: TState,
parent: Node | null
) => void
export interface SimpleCallbacks<TState> {
pre?: SimplePreCallback<TState>
post?: SimplePostCallback<TState>
}
export type SimpleVisitors<TState> = {
[type: string]: SimpleCallbacks<TState>
}
export type AncestorPreCallback<TState> = (
node: Node,
state: TState,
ancestors: Node[]
) => boolean | any
export type AncestorPostCallback<TState> = (
node: Node,
state: TState,
ancestors: Node[]
) => void
export interface AncestorCallbacks<TState> {
pre?: AncestorPreCallback<TState>
post?: AncestorPostCallback<TState>
}
export type AncestorVisitors<TState> = {
[type: string]: AncestorCallbacks<TState>
}
export type WalkerCallback<TState> = (node: Node, state: TState) => void
export type RecursiveCallback<TState> = (
node: Node,
state: TState,
walk: WalkerCallback<TState>
) => void
export type RecursiveVisitors<TState> = {
[type: string]: RecursiveCallback<TState>
}
type FindPredicate<TState> = ((node: Node, state: TState, parent: Node | null) => boolean | any) | string
export interface FindPredicates<TState> {
pre?: FindPredicate<TState>
post: FindPredicate<TState>
}
export interface FindResult<TState> {
node: Node
state: TState
parent: Node | null
}
type FindPredicateWithAncestors<TState> = ((
node: Node,
state: TState,
ancestors: Node[]
) => boolean | any) | string
export interface FindPredicatesWithAncestors<TState> {
pre?: FindPredicateWithAncestors<TState>
post: FindPredicateWithAncestors<TState>
}
export interface FindResultWithAncestors<TState> {
node: Node
state: TState
ancestors: Node[]
}
export function simple<TState> (
node: Node,
visitors: SimpleVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): void
export function ancestor<TState> (
node: Node,
visitors: AncestorVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): void
export function full<TState> (
node: Node,
callbacks: SimpleVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): void
export function fullAncestor<TState> (
node: Node,
callbacks: AncestorVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): void
export function recursive<TState> (
node: Node,
functions?: RecursiveVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): void
export function make<TState> (
functions: RecursiveVisitors<TState>,
baseVisitor?: RecursiveVisitors<TState>
): RecursiveVisitors<TState>
export function findNodeAround<TState> (
node: Node,
position: SourceLocation,
test?: FindPredicates<TState> | FindPredicate<TState> | string,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): FindResult<TState> | undefined
export function findNodeAroundWithAncestors<TState> (
node: Node,
position: SourceLocation,
test?: FindPredicatesWithAncestors<TState> | FindPredicateWithAncestors<TState> | string,
baseVisitor?: RecursiveVisitors<TState>,
state?: TState
): FindResultWithAncestors<TState> | undefined
export interface RecursiveWalkError extends Error {
node: Node
}
|
prantlf/oscript-parser
|
dist/index.d.ts
|
<gh_stars>1-10
// ============================================================
// Public API
export function parseText (input: string, options?: Options): Program
export function parseTokens (input: string, tokens: Token[], options?: Options): Program
export function tokenize (input: string, options?: Options): Token[]
export function startTokenization (input: string, options?: Options): Iterator<Token>
export const tokenTypes: TokenTypes
// ---------- Options
export const defaultOptions: Options
export interface Options {
defines?: { [key: string]: string | number | boolean }
tokens?: boolean // only for parser
preprocessor?: boolean
comments?: boolean
whitespace?: boolean
locations?: boolean
ranges?: boolean
raw?: boolean
rawIdentifiers?: boolean
rawLiterals?: boolean
sourceType?: SourceType
oldVersion?: boolean
sourceFile?: string
}
export type SourceType = 'object' | 'script' | 'dump'
// ============================================================
// Error Handling
export interface ParseWarning extends Error {
code: string
line: number
column: number
offset: number
length: number
source: string
}
export interface ParseError extends ParseWarning {
tokens?: Token[]
warnings: ParseWarning[]
}
// ============================================================
// Locations and Ranges
export interface SourceLocation {
start: Position
end: Position
source?: string | null
}
export interface Position {
line: number
column: number
}
export type Range = [number, number]
// ============================================================
// Lexer
export interface Token {
type: TokenType
value: null | boolean | number | string
line: number
lineStart: number
lastLine: number
lastLineStart: number
range: Range
hashQuote?: boolean // for identifiers
multiline?: boolean // for comments
directive?: string // for preprocessor directives
name?: string // for ifdef, ifndef, define and undef preprocessor directives
namedValue?: string // for ifdef, ifndef and define preprocessor directives
}
export type TokenType = 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 |
2048 | 8192 | 16384 | 32768
export interface TokenTypes {
EOF: 1
Whitespace: 2
Comment: 4
PreprocessorDirective: 8
PreprocessedAway: 16
Punctuator: 32
Keyword: 64
Identifier: 128
StringLiteral: 256
IntegerLiteral: 512
BooleanLiteral: 1024
UndefinedLiteral: 2048
RealLiteral: 4096
DateLiteral: 8192
ObjRef: 16384
LegacyAlias: 32768
// Combinations for matching multiple token types
KeywordOrIdentifier: 64 | 128
PunctuatorOrKeyword: 32 | 64
Literal: 256 | 512 | 1024 | 2048 | 4096 | 8182 | 16384
NoCode: 2 | 4 | 8 | 16
}
// ============================================================
// Parser
export interface Node {
type: string
loc?: SourceLocation
sourceFile?: string
range?: Range
}
export interface Program extends Node {
type: 'Program'
body: PackageDeclaration | ScriptSource | DumpSource
tokens?: Token[] // if tokens are enabled during parsing
warnings: ParseWarning[]
}
// ---------- Package
export interface PackageDeclaration extends Node {
type: 'PackageDeclaration'
name: ObjectName
object: ObjectDeclaration
}
export interface ObjectDeclaration extends Node {
type: 'ObjectDeclaration'
id: Identifier
modifier: Modifier
superObject?: ObjectName
body: MemberDeclaration[]
}
export type MemberDeclaration = FunctionDeclaration | ScriptDeclaration | FeatureDeclaration
export interface FeatureDeclaration extends Node {
type: 'FeatureDeclaration'
id: Identifier
featureType: Type
modifier?: Modifier
init?: Literal
}
export interface ObjectName extends Node {
type: 'ObjectName'
name: Array<Identifier | LegacyAlias>
}
// ---------- Script
export interface ScriptSource extends Node {
type: 'ScriptSource'
body: Array<FunctionDeclaration | Statement>
}
// ---------- Dump
export interface DumpSource extends Node {
type: 'DumpSource'
id: Identifier
parent: ObjRef
features: FeatureAddition[]
assignments: FeatureInitialization[]
scripts: ScriptDeclaration[]
}
export interface FeatureAddition extends Node {
type: 'FeatureAddition'
id: Identifier
}
export interface FeatureInitialization extends Node {
type: 'FeatureInitialization'
id: Identifier
value: Literal
}
// ---------- Scopes
export interface ScriptDeclaration extends Node {
type: 'ScriptDeclaration'
id: Identifier
modifier?: Modifier
body: Array<FunctionDeclaration | Statement>
}
export interface FunctionDeclaration extends Node {
type: 'FunctionDeclaration'
id: Identifier
functionType: Type
modifier?: Modifier
variadic: boolean
nodebug: boolean
params: Parameter[]
body: Statement[]
}
export interface Parameter extends Node {
type: 'Parameter'
id: Identifier
parameterType: Type
init?: Expression
}
// ---------- Statements
export type Statement = IfStatement | SwitchStatement | WhileStatement |
RepeatStatement | ForStatement | ForEachStatement | StructuredForStatement |
GotoStatement | ReturnStatement | BreakStatement | BreakIfStatement |
ContinueStatement | ContinueIfStatement | VariableDeclaration |
EmptyStatement | Expression
export interface IfStatement extends Node {
type: 'IfStatement'
test: Expression
consequent: Statement[]
otherClauses: ElseIfClause[]
alternate?: Statement[]
}
export interface ElseIfClause extends Node {
type: 'ElseIfClause'
test: Expression
consequent: Statement[]
}
export interface SwitchStatement extends Node {
type: 'SwitchStatement'
discriminant: Expression
cases: SwitchCase[]
}
export interface SwitchCase extends Node {
type: 'SwitchCase'
tests: Expression[]
consequent: Statement[]
}
export interface WhileStatement extends Node {
type: 'WhileStatement'
test: Expression
body: Statement[]
}
export interface RepeatStatement extends Node {
type: 'RepeatStatement'
test: Expression
body: Statement[]
}
export interface ForStatement extends Node {
type: 'ForStatement'
init?: Expression
test?: Expression
update?: Expression
body: Statement[]
}
export interface ForEachStatement extends Node {
type: 'ForEachStatement'
left: Identifier
right: Expression
body: Statement[]
}
export interface StructuredForStatement extends Node {
type: 'StructuredForStatement'
variable: Identifier
start: Expression
end: Expression
step?: Expression
down: boolean
body: Statement[]
}
export interface BreakStatement extends Node {
type: 'BreakStatement'
}
export interface ContinueStatement extends Node {
type: 'ContinueStatement'
}
export interface BreakIfStatement extends Node {
type: 'BreakIfStatement'
test: Expression
}
export interface ContinueIfStatement extends Node {
type: 'ContinueIfStatement'
test: Expression
}
export interface LabelStatement extends Node {
type: 'LabelStatement'
id: Identifier
}
export interface GotoStatement extends Node {
type: 'GotoStatement'
label: Identifier
}
export interface ReturnStatement extends Node {
type: 'ReturnStatement'
argument: Expression | undefined
}
export interface EmptyStatement extends Node {
type: 'EmptyStatement'
}
export interface VariableDeclaration extends Node {
type: 'VariableDeclaration'
variableType: Type
declarations: VariableDeclarator[]
}
export interface VariableDeclarator extends Node {
type: 'VariableDeclarator'
id: Identifier
init?: Expression
}
export type Modifier = 'override' | 'public' | 'private'
export type Type = 'Set' | 'List' | 'Date' | 'Long' | 'Real' | 'Void' |
'Assoc' | 'Bytes' | 'Frame' | 'String' | 'Record' | 'Object' |
'Boolean' | 'Integer' | 'Dynamic' | 'RecArray' | 'Error' | 'Regex' |
'Point' | 'HashMap' | 'ObjRef' | 'Script' | 'Socket' | 'File' | 'Dialog' |
'Vis' | 'CAPIERR' | 'CAPILOG' | 'PatFind' | 'WAPIMAP' |
'DOMAttr' | 'DOMNode' | 'DOMText' | 'OTQuery' | 'Compiler' | 'DAPINODE' |
'FileCopy' | 'UAPIUSER' | 'WAPIWORK' | 'OTSearch' | 'CacheTree' |
'CAPILOGIN' | 'FilePrefs' | 'PatChange' | 'SqlCursor' | 'DOMEntity' |
'DOMParser' | 'SAXParser' | 'DAPISTREAM' | 'JavaObject' | 'RestClient' |
'SslOptions' | 'DOMComment' | 'DOMElement' | 'CAPICONNECT' | 'DAPISESSION' |
'DAPIVERSION' | 'MailMessage' | 'POP3Session' | 'SMTPSession' |
'UAPISESSION' | 'WAPISESSION' | 'WAPIMAPTASK' | 'WAPISUBWORK' |
'DOMDocument' | 'DOMNodeList' | 'DOMNotation' | 'IPoolObject' |
'XSLProcessor' | 'SqlConnection' | 'DOMCdataSection' | 'DOMDocumentType' |
'DOMNamedNodeMap' | 'IPoolConnection' | 'DOMCharacterData' |
'IPoolTransaction' | 'DOMImplementation' | 'DOMEntityReference' |
'DOMDocumentFragment' | 'DOMProcessingInstruction'
// ---------- Expressions
export type Expression = BinaryExpression | ConditionalExpression
export interface ConditionalExpression extends Node {
type: 'ConditionalExpression'
test: BinaryExpression
consequent: Expression
alternate: Expression
}
export interface BinaryExpression extends Node {
type: 'BinaryExpression'
operator: BinaryOperator
left: UnaryExpression | MemberSliceCallExpression
right: UnaryExpression | MemberSliceCallExpression | BinaryExpression
}
export type BinaryOperator = ArithmeticOperator | BooleanOperator |
BitwiseOperator | LogicalOperator | AssignmentOperator
type ArithmeticOperator = '+' | '-' | '*' | '/' | '%'
type BooleanOperator =
'==' | '!=' | '<>' | '<' | '<=' | '>' | '>=' |
'in' | 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge'
type BitwiseOperator =
'<<' | '>>' | '|' | '^' | '&'
type LogicalOperator = '||' | '&&' | 'or' | 'and'
type AssignmentOperator =
'=' | '+=' | '-=' | '*=' | '/=' | '%=' | '<<=' | '>>=' | '|=' | '^=' | '&='
export interface UnaryExpression extends Node {
type: 'UnaryExpression'
operator: UnaryOperator
argument: UnaryExpression | MemberSliceCallExpression
}
export type UnaryOperator = '-' | '!' | '~' | 'not'
export type MemberSliceCallExpression = PrimaryExpression | MemberExpression |
SliceExpression | CallExpression
export type MemberExpression = SimpleMemberExpression | BoxedMemberExpression
export interface BaseMemberExpression extends Node {
type: 'MemberExpression'
object: MemberSliceCallExpression
}
export interface SimpleMemberExpression extends BaseMemberExpression {
property: Identifier | Literal
}
export interface BoxedMemberExpression extends BaseMemberExpression {
property: Expression
boxed: true
}
export interface SliceExpression extends Node {
type: 'SliceExpression'
object: MemberSliceCallExpression
start?: Expression
end?: Expression
}
export interface IndexExpression extends Node {
type: 'IndexExpression'
object: MemberSliceCallExpression
index: Expression
}
export interface CallExpression extends Node {
type: 'CallExpression'
callee: MemberSliceCallExpression
arguments: Expression[]
}
export type PrimaryExpression = XlateExpression | ParenthesisExpression |
ThisExpression | SuperExpression | AssocExpression | ListExpression |
ListComprehension | ObjectName | Identifier | Literal | ObjectExpression
export interface ThisExpression extends Node {
type: 'ThisExpression'
}
export interface SuperExpression extends Node {
type: 'SuperExpression'
}
export interface AssocExpression extends Node {
type: 'AssocExpression'
properties: Property[]
}
export type ObjectExpression = AssocExpression
export interface Property extends Node {
type: 'Property'
key: Expression
value: Expression
}
export interface ListExpression extends Node {
type: 'ListExpression'
elements: Expression[]
}
export interface ListComprehension extends Node {
type: 'ListComprehension'
expression: AtExpression | Expression
left: Identifier
right: Expression
test?: Expression
}
export interface AtExpression extends Node {
type: 'AtExpression'
expression: Expression
}
export interface ParenthesisExpression extends Node {
type: 'ParenthesisExpression'
expression: Expression
}
export interface XlateExpression extends Node {
type: 'XlateExpression'
ospace: Identifier
string: Identifier
}
// ---------- Identifiers
export interface Identifier extends Node {
type: 'Identifier'
value: string
raw?: string
}
export interface LegacyAlias extends Node {
type: 'LegacyAlias'
value: number
raw?: string
}
// ---------- Literals
export interface Literal extends Node {
type: 'Literal'
literalType: LiteralType
value: string | boolean | number | null
raw?: string
}
export type LiteralType = 'string' | 'integer' | 'real' | 'date' | 'objref' |
'boolean' | 'undefined'
export interface StringLiteral extends Literal {
literalType: 'string'
}
export interface IntegerLiteral extends Literal {
literalType: 'integer'
}
export interface RealLiteral extends Literal {
literalType: 'real'
}
export interface DateLiteral extends Literal {
literalType: 'date'
}
export interface ObjRef extends Literal {
literalType: 'objref'
}
export interface BooleanLiteral extends Literal {
literalType: 'boolean'
}
export interface UndefinedLiteral extends Literal {
literalType: 'undefined'
}
|
prantlf/oscript-parser
|
pkg/interpreter/dist/index.d.ts
|
import { Node } from 'oscript-parser'
// ============================================================
// Public API
export function interpret (ast: Node, options?: Options): ValueType
// ---------- Options
export interface Options {
globals?: Globals
warnings?: boolean
}
export type Globals = { [key: string]: ValueType }
export type PrimitiveType = undefined | boolean | number | string
export type ValueType = PrimitiveType | ValueType[] | { [key: string]: ValueType }
// ============================================================
// Error Handling
export interface InterpreterError extends Error {
node: Node
}
export interface NotImplementedError extends InterpreterError {}
export interface RuntimeError extends InterpreterError {}
|
aneldev/dyna-ui-utils
|
src/getPageYPosition.ts
|
export const getPageYPosition = ():number => {
// Firefox, Chrome, Opera, Safari
if (self.pageYOffset) return self.pageYOffset;
// Internet Explorer 6 - standards mode
if (document.documentElement && document.documentElement.scrollTop)
return document.documentElement.scrollTop;
// Internet Explorer 6, 7 and 8
if (document.body.scrollTop) return document.body.scrollTop;
return 0;
};
|
aneldev/dyna-ui-utils
|
src/smoothScrollToY.ts
|
<gh_stars>0
import {getPageYPosition} from "./getPageYPosition";
export const smoothScrollToY = (y: number, duration: number): void => {
let startY = getPageYPosition();
let stopY = y;
let distance = stopY > startY ? stopY - startY : startY - stopY;
if (distance < duration) {
scrollTo(0, stopY);
return;
}
let speed = Math.round(distance / duration);
if (speed >= 20) speed = 20;
let step = Math.round(distance / 25);
let leapY = stopY > startY ? startY + step : startY - step;
let timer = 0;
if (stopY > startY) {
for (let i = startY; i < stopY; i += step) {
setTimeout("window.scrollTo(0, " + leapY + ")", timer * speed);
leapY += step;
if (leapY > stopY) leapY = stopY;
timer++;
}
return;
}
for (let i = startY; i > stopY; i -= step) {
setTimeout("window.scrollTo(0, " + leapY + ")", timer * speed);
leapY -= step;
if (leapY < stopY) leapY = stopY;
timer++;
}
};
|
aneldev/dyna-ui-utils
|
src/scrollPageToTop.ts
|
export const scrollPageToTop = (scrollDuration: number): void => {
if (typeof window.scrollY === 'undefined') {
window.scrollTo(0);
return;
}
const scrollHeight = window.scrollY,
scrollStep = Math.PI / (scrollDuration / 15),
cosParameter = scrollHeight / 2;
let scrollCount = 0,
scrollMargin,
scrollInterval = setInterval(function () {
if (window.scrollY !== 0) {
scrollCount = scrollCount + 1;
scrollMargin = cosParameter - cosParameter * Math.cos(scrollCount * scrollStep);
window.scrollTo(0, (scrollHeight - scrollMargin));
}
else clearInterval(scrollInterval);
}, 15);
};
|
aneldev/dyna-ui-utils
|
src/getElementViewportPercent.ts
|
<reponame>aneldev/dyna-ui-utils
export const getElementViewportPercent = (element: HTMLElement): number => {
if (element.offsetParent === null) return 0;
const windowHeight: number = window.innerHeight || document.documentElement.clientHeight;
const clientRect: ClientRect = element.getBoundingClientRect();
let elementVisibleHeight: number =
clientRect.top > 0
? windowHeight - clientRect.top
: clientRect.height + clientRect.top;
if (elementVisibleHeight <= 0) return 0;
if (elementVisibleHeight >= clientRect.height) return 100;
return 100 * elementVisibleHeight / clientRect.height;
};
|
aneldev/dyna-ui-utils
|
dist/index.d.ts
|
<filename>dist/index.d.ts<gh_stars>0
export interface IPerson {
name: string;
age: number;
}
export declare class Person {
private name;
private age;
constructor(name: string, age: number);
getName(): string;
getAge(): number;
get(): IPerson;
}
|
aneldev/dyna-ui-utils
|
src/scrollToElement.ts
|
<reponame>aneldev/dyna-ui-utils
export const scrollToElement = (container: HTMLElement, element: HTMLElement): boolean => {
if (!container || !element) return false;
if (element.offsetTop < container.scrollTop) {
container.scrollTop = element.offsetTop;
container.scrollTop -= element.offsetHeight / 2;
}
if (element.offsetTop + element.offsetHeight > container.offsetHeight + container.scrollTop) {
container.scrollTop = (element.offsetTop + element.offsetHeight) - container.offsetHeight;
container.scrollTop += element.offsetHeight / 2;
}
return true;
};
|
aneldev/dyna-ui-utils
|
src/isElementHidden.ts
|
export const isElementHidden = (element: HTMLElement): boolean => {
return (element.offsetParent === null)
};
|
aneldev/dyna-ui-utils
|
src/index.ts
|
<filename>src/index.ts
export {scrollToElement} from "./scrollToElement";
export {scrollPageToTop} from "./scrollPageToTop";
export {isElementHidden} from "./isElementHidden";
export {getElementViewportPercent} from "./getElementViewportPercent";
export {getPageYPosition} from "./getPageYPosition";
export {smoothScrollToY} from "./smoothScrollToY";
export {downloadFromCode} from "./downloadFromCode";
|
JCCDex/jcc-rescue-donated
|
mobile/js/util.ts
|
<reponame>JCCDex/jcc-rescue-donated<filename>mobile/js/util.ts
const browser = {
versions: (function() {
let u = navigator.userAgent;
return {
ios: !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/),
android: u.indexOf("Android") > -1 || u.indexOf("Adr") > -1
};
})()
};
export { browser };
|
XiaoLin1995/vite-plugin-lint
|
src/index.ts
|
<reponame>XiaoLin1995/vite-plugin-lint<filename>src/index.ts
import eslintPlugin from './eslint'
import stylelintPlugin from './stylelint'
export { eslintPlugin, stylelintPlugin }
|
XiaoLin1995/vite-plugin-lint
|
src/eslint/index.ts
|
<reponame>XiaoLin1995/vite-plugin-lint
import path from 'path'
import type { Plugin } from 'vite'
import { ESLint } from 'eslint'
import { createFilter } from '@rollup/pluginutils'
import { checkVueFile, normalizePath, Options } from '../utils'
export default function eslintPlugin(options: Options = {}): Plugin {
const defaultOptions: Options = {
cache: false,
fix: false,
include: /.*\.(vue|js|jsx|ts|tsx)/,
exclude: /node_modules/,
throwOnWarning: true,
throwOnError: true
}
const opts = { ...defaultOptions, ...options }
const eslint = new ESLint({
cacheLocation: path.resolve(
process.cwd(),
// maybe vite config cacheDir is better ?
'./node_modules/.vite/vite-plugin-eslint'
),
cache: opts.cache,
fix: opts.fix
})
const filter = createFilter(opts.include, opts.exclude)
let formatter: ESLint.Formatter
return {
name: 'vite:eslint',
async transform(_, id) {
const file = normalizePath(id)
if (!filter(id) || (await eslint.isPathIgnored(file)) || checkVueFile(id)) {
return null
}
switch (typeof opts.formatter) {
case 'string':
formatter = await eslint.loadFormatter(opts.formatter)
break
case 'function':
;({ formatter } = opts)
break
default:
formatter = await eslint.loadFormatter('stylish')
}
const report = await eslint.lintFiles(file)
const hasWarnings = opts.throwOnWarning && report.some((item) => item.warningCount !== 0)
const hasErrors = opts.throwOnError && report.some((item) => item.errorCount !== 0)
const result = formatter.format(report)
if (opts.fix && report) ESLint.outputFixes(report)
// if (hasWarnings) this.warn(result);
// if (hasErrors) this.error(result);
if (hasWarnings || hasErrors) console.log(result)
return null
}
}
}
|
XiaoLin1995/vite-plugin-lint
|
src/utils.ts
|
import qs from 'querystring'
import path from 'path'
import type { ESLint } from 'eslint'
import { clearTimeout, setTimeout } from 'timers'
export interface Options {
/** The cache is enabled by default to decrease execution time */
cache?: boolean
/** auto fix source code */
fix?: boolean
/**
* A single file, or array of files, to include when linting.
* @default eslint /.*\.(vue|js|jsx|ts|tsx)/
* @default stylelint /.*\.(vue|scss|sass|css|postcss)/
*/
include?: string | string[] | RegExp
/**
* A single file, or array of files, to exclude when linting.
* @default /node_modules/
*/
exclude?: string | string[] | RegExp
/** Custom error formatter or the name of a built-in formatter */
formatter?: string | ESLint.Formatter
/** The warings found will be emitted */
throwOnWarning?: boolean
/** The errors found will be emitted */
throwOnError?: boolean
}
export function normalizePath(id: string): string {
return path.relative(process.cwd(), id).split('?')[0].split(path.sep).join('/')
}
export function checkVueFile(id: string): boolean {
if (!id.includes('?')) return false
const rawQuery = id.split('?', 2)[1]
return qs.parse(rawQuery).vue !== null ? true : false
}
/**
* Collection of stylelint formatted outputs.
* Helps to prevent loosing previously added outputs on any Vite dev-server update.
* @key filePath
* @value stylelinter output
*/
export type OutputCollection = Map<string, string>
/**
* Creates specific Map to handle linter outputs
*/
export function createOutputCollection(): OutputCollection {
return new Map<string, string>()
}
/**
* Debounce timeout for disaplying outputs
*/
let timeoutId: NodeJS.Timeout
/**
* Displays error stack via terminal (debounced)
*/
export function displayOutput(collection: OutputCollection): void {
clearTimeout(timeoutId)
timeoutId = setTimeout(() => {
debouncedDisplayOutput(collection)
}, 200)
}
/**
* Debounced function to prevent multiple output display at dev-server updates
*/
function debouncedDisplayOutput(collection: OutputCollection): void {
collection.forEach((output) => {
console.log(output)
})
}
|
XiaoLin1995/vite-plugin-lint
|
src/stylelint/index.ts
|
import { createFilter } from '@rollup/pluginutils'
import stylelint from 'stylelint'
import { normalizePath, createOutputCollection, displayOutput, Options } from '../utils'
import type { Plugin } from 'vite'
export default function stylelintPlugin(options: Options = {}): Plugin {
const defaultOptions: Options = {
include: /.*\.(vue|scss|sass|css|postcss)/,
exclude: /node_modules/
}
const opts = { ...defaultOptions, ...options }
const filter = createFilter(opts.include, opts.exclude)
const outputCollection = createOutputCollection()
return {
name: 'vite:stylelint',
async transform(code, id) {
const file = normalizePath(id)
if (!filter(id)) {
return null
}
await stylelint
.lint({
files: file,
formatter: 'string'
})
.then(({ errored, output }) => {
if (errored) {
outputCollection.set(file, output)
} else if (outputCollection.has(file)) {
outputCollection.delete(file)
}
})
.catch((error) => {
// this.error(error)
console.log(error)
})
.finally(() => {
displayOutput(outputCollection)
})
}
// configureServer() {
// console.log('vite-plugin-stylelint enabled')
// }
}
}
|
moots-technology/moots-datetime-picker
|
src/moots-picker/services/calendar.service.ts
|
import { Injectable } from '@angular/core';
import * as moment from 'moment';
import { CalendarDay, CalendarMonth, CalendarOriginal, CalendarResult, DayConfig, GlobalPickState, PickMode, PickerModalOptions } from '../calendar.model';
import { defaults } from '../config';
const isBoolean = (input: any) => input === true || input === false;
@Injectable()
export class CalendarService {
constructor() {/**/}
get DEFAULT_STEP() {
return 12;
}
safeOpt(calendarOptions: any = {}): PickerModalOptions {
const _disableWeeks: number[] = [];
const _daysConfig: DayConfig[] = [];
const {
from = new Date(),
to = 0,
weekStart = 0,
step = this.DEFAULT_STEP,
id = '',
cssClass = '',
closeLabel = 'CANCEL',
doneLabel = 'DONE',
monthFormat = 'MMM YYYY',
title = 'CALENDAR',
defaultTitle = '',
defaultSubtitle = '',
autoDone = false,
canBackwardsSelected = false,
closeIcon = false,
doneIcon = false,
// showYearPicker = false,
isSaveHistory = false,
pickMode = PickMode.SINGLE,
color = defaults.COLOR,
weekdays = defaults.WEEKS_FORMAT,
daysConfig = _daysConfig,
disableWeeks = _disableWeeks,
showAdjacentMonthDay = true,
locale = 'en',
startLabel = 'Start',
endLabel = 'End',
fulldayLabel = 'All Day event',
fullday = false,
tapticConf = {
onClockHover: () => { /**/ },
onClockSelect: () => { /**/ },
onCalendarSelect: () => { /**/ },
},
pickState = GlobalPickState.BEGIN_DATE
} = calendarOptions || {};
return {
id,
from,
to,
pickMode,
autoDone,
color,
cssClass,
weekStart,
closeLabel,
closeIcon,
doneLabel,
doneIcon,
canBackwardsSelected,
isSaveHistory,
disableWeeks,
monthFormat,
title,
weekdays,
daysConfig,
step,
defaultTitle,
defaultSubtitle,
defaultScrollTo: calendarOptions.defaultScrollTo || from,
defaultDate: calendarOptions.defaultDate || undefined,
defaultDates: calendarOptions.defaultDates || undefined,
defaultDateRange: calendarOptions.defaultDateRange || undefined,
showAdjacentMonthDay,
locale,
startLabel,
endLabel,
fulldayLabel,
fullday,
tapticConf,
pickState
};
}
createOriginalCalendar(time: number): CalendarOriginal {
const date = new Date(time);
const year = date.getFullYear();
const month = date.getMonth();
const firstWeek = new Date(year, month, 1).getDay();
const howManyDays = moment(time).daysInMonth();
return {
year,
month,
firstWeek,
howManyDays,
time: new Date(year, month, 1).getTime(),
date: moment(time),
};
}
findDayConfig(day: any, opt: PickerModalOptions): any {
if (opt.daysConfig.length <= 0) { return undefined; }
return opt.daysConfig.find(n => day.isSame(n.date, 'day'));
}
createCalendarDay(time: number, opt: PickerModalOptions, month?: number): CalendarDay {
const _time = moment(time);
const date = moment(time);
const isToday = moment().isSame(_time, 'days');
const dayConfig = this.findDayConfig(_time, opt);
const _rangeBeg = moment(opt.from).valueOf();
const _rangeEnd = moment(opt.to).valueOf();
let isBetween = true;
const disableWee = opt.disableWeeks.indexOf(_time.toDate().getDay()) !== -1;
if (_rangeBeg > 0 && _rangeEnd > 0) {
isBetween = opt.canBackwardsSelected ? (moment(_time).isBefore(_rangeBeg) ? false : isBetween)
: !_time.isBetween(_rangeBeg, _rangeEnd, 'days', '[]');
} else if (_rangeBeg > 0 && _rangeEnd === 0) {
if (!opt.canBackwardsSelected) {
const _addTime = _time.add(1, 'day');
isBetween = !_addTime.isAfter(_rangeBeg);
} else {
isBetween = false;
}
}
let _disable = false;
_disable = (dayConfig && isBoolean(dayConfig.disable)) ? dayConfig.disable : (disableWee || isBetween);
let title = new Date(time).getDate().toString();
if (dayConfig && dayConfig.title) {
title = dayConfig.title;
} else if (opt.defaultTitle) {
title = opt.defaultTitle;
}
let subTitle = '';
if (dayConfig && dayConfig.subTitle) {
subTitle = dayConfig.subTitle;
} else if (opt.defaultSubtitle) {
subTitle = opt.defaultSubtitle;
}
return {
time,
isToday,
title,
subTitle,
selected: false,
isLastMonth: date.month() < month,
isNextMonth: date.month() > month,
marked: dayConfig ? dayConfig.marked || false : false,
cssClass: dayConfig ? dayConfig.cssClass || '' : '',
disable: _disable,
isFirst: date.date() === 1,
isLast: date.date() === date.daysInMonth(),
};
}
createCalendarMonth(original: CalendarOriginal, opt: PickerModalOptions): CalendarMonth {
const days: CalendarDay[] = new Array(6).fill(undefined);
const len = original.howManyDays;
for (let i = original.firstWeek; i < len + original.firstWeek; i++) {
const itemTime = new Date(original.year, original.month, i - original.firstWeek + 1).getTime();
days[i] = this.createCalendarDay(itemTime, opt);
}
const weekStart = opt.weekStart;
if (weekStart === 1) {
if (days[0] === undefined) {
days.shift();
} else {
days.unshift(...new Array(6).fill(undefined));
}
}
if (opt.showAdjacentMonthDay) {
const _booleanMap = days.map(e => !!e);
const thisMonth = moment(original.time).month();
let startOffsetIndex = _booleanMap.indexOf(true) - 1;
let endOffsetIndex = _booleanMap.lastIndexOf(true) + 1;
for (startOffsetIndex; startOffsetIndex >= 0; startOffsetIndex--) {
const dayBefore = moment(days[startOffsetIndex + 1].time)
.clone()
.subtract(1, 'd');
days[startOffsetIndex] = this.createCalendarDay(dayBefore.valueOf(), opt, thisMonth);
}
if (!(_booleanMap.length % 7 === 0 && _booleanMap[_booleanMap.length - 1])) {
for (endOffsetIndex; endOffsetIndex < days.length + (endOffsetIndex % 7); endOffsetIndex++) {
const dayAfter = moment(days[endOffsetIndex - 1].time)
.clone()
.add(1, 'd');
days[endOffsetIndex] = this.createCalendarDay(dayAfter.valueOf(), opt, thisMonth);
}
}
}
return {
days,
original
};
}
createMonthsByPeriod(startTime: number, monthsNum: number, opt: PickerModalOptions): CalendarMonth[] {
const _array: CalendarMonth[] = [];
const _start = new Date(startTime);
const _startMonth = new Date(_start.getFullYear(), _start.getMonth(), 1).getTime();
for (let i = 0; i < monthsNum; i++) {
const time = moment(_startMonth)
.add(i, 'M')
.valueOf();
const originalCalendar = this.createOriginalCalendar(time);
_array.push(this.createCalendarMonth(originalCalendar, opt));
}
return _array;
}
wrapResult(original: CalendarDay[], times: moment.Moment[], pickMode: PickMode) {
const secondIndex = original[1] ? 1 : 0;
let result: any;
switch (pickMode) {
case PickMode.SINGLE:
result = this.multiFormat(original[0].time);
break;
case PickMode.RANGE:
result = {
from: this.multiFormat(moment(original[0].time).hours(times[0].hours()).minutes(times[0].minutes()).startOf('minute').valueOf()),
to: this.multiFormat(moment(original[secondIndex].time).hours(times[1].hours()).minutes(times[1].minutes()).startOf('minute').valueOf()),
};
break;
case PickMode.MULTI:
result = original.map(e => this.multiFormat(e.time));
break;
default:
result = original;
}
return result;
}
multiFormat(time: number): CalendarResult {
const _moment = moment(time);
return {
time: _moment.valueOf(),
unix: _moment.unix(),
dateObj: _moment.toDate(),
string: _moment.format(defaults.DATE_FORMAT),
years: _moment.year(),
months: _moment.month() + 1,
date: _moment.date(),
};
}
}
|
moots-technology/moots-datetime-picker
|
src/tests/modal-basic.ts
|
<filename>src/tests/modal-basic.ts
import { Component, ElementRef } from '@angular/core';
import { ModalController } from '@ionic/angular';
import { NavParamsMock } from 'ionic-mocks';
import * as moment from 'moment';
import { PickMode, PickerModal, PickerModalOptions } from '../moots-picker';
import { CalendarService } from '../moots-picker/services/calendar.service';
import { CDRefMock, ModalCtrlMock, RendererMock } from './test-mocks';
@Component({
selector: 'demo-modal-basic',
template: `
<ion-button (click)="openCalendar()">
basic
</ion-button>
`,
})
/** Creates and opens a basic modal picker to be tested */
export class DemoModalBasicComponent {
currentDate: moment.Moment = moment();
dateRange = {
from: this.currentDate,
to: this.currentDate,
};
modalCtrlMock: ModalController = new ModalCtrlMock();
myPicker: PickerModal;
constructor() { /**/ }
async openCalendar() {
const options: PickerModalOptions = {
pickMode: PickMode.RANGE,
title: 'RANGE',
defaultDateRange: this.dateRange,
canBackwardsSelected: false,
weekStart: 1,
step: 4,
locale: window.navigator.language,
};
const rendererMock = new RendererMock();
const elemRefMock = new ElementRef(undefined);
const cdRefMock = new CDRefMock();
this.myPicker = new PickerModal(rendererMock, elemRefMock, NavParamsMock.instance(), this.modalCtrlMock, cdRefMock, new CalendarService());
this.myPicker.options = options;
this.myPicker.ngOnInit();
}
}
|
moots-technology/moots-datetime-picker
|
src/demos/demos.module.ts
|
import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { IonicModule } from '@ionic/angular';
import { MootsPickerModule } from '../moots-picker';
import { DemoComponentBasicComponent } from './component-basic';
import { DemoModalBasicComponent } from './demo-modal-basic';
import { DemoMultiComponent } from './demo-multi';
import { DemoOptionsComponent } from './demo-options';
import { DemoRangeComponent } from './demo-range';
import { SubHeaderCalendarModal } from './sub-header-calendar-modal';
const COMPONENTS = [
DemoModalBasicComponent,
SubHeaderCalendarModal,
DemoMultiComponent,
DemoRangeComponent,
DemoOptionsComponent,
DemoComponentBasicComponent
];
@NgModule({
declarations: [...COMPONENTS],
imports: [CommonModule, IonicModule, FormsModule, MootsPickerModule],
exports: [...COMPONENTS],
entryComponents: [...COMPONENTS],
})
export class DemosModule {}
|
moots-technology/moots-datetime-picker
|
src/tests/modal-basic.spec.ts
|
import { NO_ERRORS_SCHEMA } from '@angular/core';
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { ModalController } from '@ionic/angular';
import * as moment from 'moment';
import { DemoModalBasicComponent } from './modal-basic';
describe('DemoModalBasicComponent', () => {
let component: DemoModalBasicComponent;
let fixture: ComponentFixture<DemoModalBasicComponent>;
beforeEach(() => {
const modalControllerStub = { create: () => ({}) };
TestBed.configureTestingModule({
schemas: [NO_ERRORS_SCHEMA],
declarations: [DemoModalBasicComponent],
providers: [
{ provide: ModalController, useValue: modalControllerStub }
]
});
fixture = TestBed.createComponent(DemoModalBasicComponent);
component = fixture.componentInstance;
});
// ===================== TESTS =====================
it('can load instance', () => {
expect(component).toBeTruthy();
});
it('return undefined on cancel', () => {
const dismissSpy = spyOn(component.modalCtrlMock, 'dismiss');
component.openCalendar();
component.myPicker.onCancel();
expect(dismissSpy).toHaveBeenCalledWith(undefined, 'cancel');
});
it('return input with duration 30 minutes if unchanged and no to-Date', () => {
const testDate = moment().add(1, 'hour').minutes(0).startOf('minute');
component.dateRange = {
from: testDate,
to: testDate,
};
const dismissSpy = spyOn(component.modalCtrlMock, 'dismiss');
component.openCalendar();
component.myPicker.done();
component.dateRange.to = moment(testDate).add(30, 'minute');
expect(dismissSpy.calls.mostRecent().args[1]).toBe('done');
expect(dismissSpy.calls.mostRecent().args[0].from.time).toBe(moment(component.dateRange.from).valueOf());
expect(dismissSpy.calls.mostRecent().args[0].to.time).toBe(moment(component.dateRange.to).valueOf());
});
it('return input if valid to-from supplied', () => {
const testDate = moment().add(1, 'hour').minutes(0).startOf('minute');
component.dateRange = {
from: testDate,
to: moment().add(2, 'hour').minutes(0).startOf('minute'),
};
const dismissSpy = spyOn(component.modalCtrlMock, 'dismiss');
component.openCalendar();
component.myPicker.done();
expect(dismissSpy.calls.mostRecent().args[1]).toBe('done');
expect(dismissSpy.calls.mostRecent().args[0].from.time).toBe(moment(component.dateRange.from).valueOf());
expect(dismissSpy.calls.mostRecent().args[0].to.time).toBe(moment(component.dateRange.to).valueOf());
});
it('prevent invalid input dates from being returned', () => {
const testDate = moment().add(1, 'hour').minutes(0).startOf('minute');
const expectedTo = moment(testDate).add(30, 'minute');
component.dateRange = {
from: testDate,
to: moment(testDate).subtract(2, 'hour'),
};
const dismissSpy = spyOn(component.modalCtrlMock, 'dismiss');
component.openCalendar();
component.myPicker.done();
expect(dismissSpy.calls.mostRecent().args[1]).toBe('done');
expect(dismissSpy.calls.mostRecent().args[0].from.time).toBe(moment(component.dateRange.from).valueOf());
expect(dismissSpy.calls.mostRecent().args[0].to.time).toBe(moment(expectedTo).valueOf());
});
});
|
moots-technology/moots-datetime-picker
|
src/moots-picker/components/calendar.component.ts
|
<reponame>moots-technology/moots-datetime-picker<filename>src/moots-picker/components/calendar.component.ts<gh_stars>10-100
import { Component, EventEmitter, Input, OnInit, Output, Provider, forwardRef } from '@angular/core';
import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
import * as moment from 'moment';
import { CalendarComponentMonthChange, CalendarComponentOptions, CalendarComponentPayloadTypes, CalendarDay, CalendarMonth, PickMode, PickerModalOptions } from '../calendar.model';
import { defaults } from '../config';
import { CalendarService } from '../services/calendar.service';
export const ION_CAL_VALUE_ACCESSOR: Provider = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => CalendarComponent),
multi: true
};
@Component({
selector: 'moots-picker-calendar',
providers: [ION_CAL_VALUE_ACCESSOR],
styleUrls: ['./calendar.component.scss'],
templateUrl: 'calendar.component.html'
})
export class CalendarComponent implements ControlValueAccessor, OnInit {
_d: PickerModalOptions;
_options: CalendarComponentOptions;
_view: 'month' | 'days' = 'days';
_calendarMonthValue: CalendarDay[] = [undefined, undefined];
_showToggleButtons = true;
get showToggleButtons(): boolean {
return this._showToggleButtons;
}
set showToggleButtons(value: boolean) {
this._showToggleButtons = value;
}
_showMonthPicker = true;
get showMonthPicker(): boolean {
return this._showMonthPicker;
}
set showMonthPicker(value: boolean) {
this._showMonthPicker = value;
}
monthOpt: CalendarMonth;
@Input()
format: string = defaults.DATE_FORMAT;
@Input()
readonly = false;
@Output()
change: EventEmitter<CalendarComponentPayloadTypes> = new EventEmitter();
@Output()
monthChange: EventEmitter<CalendarComponentMonthChange> = new EventEmitter();
@Output()
select: EventEmitter<CalendarDay> = new EventEmitter();
@Output()
selectStart: EventEmitter<CalendarDay> = new EventEmitter();
@Output()
selectEnd: EventEmitter<CalendarDay> = new EventEmitter();
@Input()
set options(value: CalendarComponentOptions) {
this._options = value;
this.initOpt();
if (this.monthOpt && this.monthOpt.original) {
this.monthOpt = this.createMonth(this.monthOpt.original.time);
}
}
get options(): CalendarComponentOptions {
return this._options;
}
constructor(public calSvc: CalendarService) { }
ngOnInit(): void {
this.initOpt();
this.monthOpt = this.createMonth(new Date().getTime());
}
getViewDate() {
return moment(this.monthOpt.original.time);
}
setViewDate(value: CalendarComponentPayloadTypes) {
this.monthOpt = this.createMonth(this._payloadToTimeNumber(value));
}
switchView(): void {
this._view = this._view === 'days' ? 'month' : 'days';
}
prev(): void {
if (this._view === 'days') {
this.backMonth();
} else {
this.prevYear();
}
}
next(): void {
if (this._view === 'days') {
this.nextMonth();
} else {
this.nextYear();
}
}
prevYear(): void {
if (moment(this.monthOpt.original.time).year() === 1970) {
return;
}
const backTime = moment(this.monthOpt.original.time)
.subtract(1, 'year')
.valueOf();
this.monthOpt = this.createMonth(backTime);
}
nextYear(): void {
const nextTime = moment(this.monthOpt.original.time)
.add(1, 'year')
.valueOf();
this.monthOpt = this.createMonth(nextTime);
}
nextMonth(): void {
const nextTime = moment(this.monthOpt.original.time)
.add(1, 'months')
.valueOf();
this.monthChange.emit({
oldMonth: this.calSvc.multiFormat(this.monthOpt.original.time),
newMonth: this.calSvc.multiFormat(nextTime)
});
this.monthOpt = this.createMonth(nextTime);
}
canNext(): boolean {
if (!this._d.to || this._view !== 'days') {
return true;
}
return this.monthOpt.original.time < moment(this._d.to).valueOf();
}
backMonth(): void {
const backTime = moment(this.monthOpt.original.time)
.subtract(1, 'months')
.valueOf();
this.monthChange.emit({
oldMonth: this.calSvc.multiFormat(this.monthOpt.original.time),
newMonth: this.calSvc.multiFormat(backTime)
});
this.monthOpt = this.createMonth(backTime);
}
canBack(): boolean {
if (!this._d.from || this._view !== 'days') {
return true;
}
return this.monthOpt.original.time > moment(this._d.from).valueOf();
}
monthOnSelect(month: number): void {
this._view = 'days';
const newMonth = moment(this.monthOpt.original.time)
.month(month)
.valueOf();
this.monthChange.emit({
oldMonth: this.calSvc.multiFormat(this.monthOpt.original.time),
newMonth: this.calSvc.multiFormat(newMonth)
});
this.monthOpt = this.createMonth(newMonth);
}
onChanged($event: CalendarDay[]): void {
switch (this._d.pickMode) {
case PickMode.SINGLE:
const date = moment($event[0].time);
this._onChanged(date);
this.change.emit(date);
break;
case PickMode.RANGE:
if ($event[0] && $event[1]) {
const rangeDate = {
from: moment($event[0].time),
to: moment($event[1].time)
};
this._onChanged(rangeDate);
this.change.emit(rangeDate);
}
break;
case PickMode.MULTI:
const dates = [];
for (const evnt of $event) {
if (evnt && evnt.time) {
dates.push(moment(evnt.time));
}
}
this._onChanged(dates);
this.change.emit(dates);
break;
default:
}
}
swipeEvent($event: any): void {
const isNext = $event.deltaX < 0;
if (isNext && this.canNext()) {
this.nextMonth();
} else if (!isNext && this.canBack()) {
this.backMonth();
}
}
_onChanged = (_date: any) => {/**/ };
_onTouched = () => {/**/ };
_payloadToTimeNumber(value: CalendarComponentPayloadTypes): number {
const date = moment(value);
return date.valueOf();
}
_monthFormat(date: number): string {
return moment(date).format(this._d.monthFormat.replace(/y/g, 'Y'));
}
private initOpt(): void {
if (
this._options &&
typeof this._options.showToggleButtons === 'boolean'
) {
this.showToggleButtons = this._options.showToggleButtons;
}
if (
this._options &&
typeof this._options.showMonthPicker === 'boolean'
) {
this.showMonthPicker = this._options.showMonthPicker;
if (this._view !== 'days' && !this.showMonthPicker) {
this._view = 'days';
}
}
this._d = this.calSvc.safeOpt(this._options || {});
}
createMonth(date: number): CalendarMonth {
return this.calSvc.createMonthsByPeriod(date, 1, this._d)[0];
}
_createCalendarDay(value: string): CalendarDay {
return this.calSvc.createCalendarDay(this._payloadToTimeNumber(value), this._d);
}
writeValue(obj: any): void {
this._writeValue(obj);
if (obj) {
if (this._calendarMonthValue[0]) {
this.monthOpt = this.createMonth(
this._calendarMonthValue[0].time
);
} else {
this.monthOpt = this.createMonth(new Date().getTime());
}
}
}
registerOnChange(fn: () => {}): void {
this._onChanged = fn;
}
registerOnTouched(fn: () => {}): void {
this._onTouched = fn;
}
_writeValue(value: any): void {
if (!value) {
this._calendarMonthValue = [undefined, undefined];
return;
}
switch (this._d.pickMode) {
case PickMode.SINGLE:
this._calendarMonthValue[0] = this._createCalendarDay(value);
break;
case PickMode.RANGE:
if (value.from) {
this._calendarMonthValue[0] = value.from
? this._createCalendarDay(value.from)
: undefined;
}
if (value.to) {
this._calendarMonthValue[1] = value.to
? this._createCalendarDay(value.to)
: undefined;
}
break;
case PickMode.MULTI:
if (Array.isArray(value)) {
this._calendarMonthValue = value.map(e => {
return this._createCalendarDay(e);
});
} else {
this._calendarMonthValue = [undefined, undefined];
}
break;
default:
}
}
}
|
moots-technology/moots-datetime-picker
|
src/moots-picker/config.ts
|
export const defaults = {
DATE_FORMAT: 'YYYY-MM-DD',
COLOR: 'primary',
WEEKS_FORMAT: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
MONTH_FORMAT: ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
};
|
moots-technology/moots-datetime-picker
|
src/demos/demo-multi.ts
|
<gh_stars>10-100
import { Component } from '@angular/core';
import { ModalController } from '@ionic/angular';
import * as moment from 'moment';
import { CalendarComponentOptions, PickMode } from '../moots-picker';
@Component({
selector: 'demo-multi',
template: `
<hr>
<h3 style="text-align: center;">multi</h3>
<moots-picker-calendar [(ngModel)]="date"
(onChange)="onChange($event)"
[options]="options"
type="string"
format="YYYY-MM-DD">
</moots-picker-calendar>
`,
})
export class DemoMultiComponent {
date: string[] = ['2018-01-01', '2018-01-02', '2018-01-05'];
options: CalendarComponentOptions = {
from: moment(new Date(2000, 0, 1)),
pickMode: PickMode.MULTI,
};
constructor(public modalCtrl: ModalController) {}
onChange($event: any) {
console.log($event);
}
}
|
moots-technology/moots-datetime-picker
|
src/moots-picker/components/calendar.modal.ts
|
import { animate, state, style, transition, trigger } from '@angular/animations';
import { AfterViewInit, ChangeDetectorRef, Component, ElementRef, HostBinding, Input, OnInit, Renderer2, ViewChild } from '@angular/core';
import { IonContent, ModalController, NavParams } from '@ionic/angular';
import * as moment from 'moment';
import { CalendarDay, CalendarMonth, GlobalPickState, PickMode, PickerModalOptions } from '../calendar.model';
import { CalendarService } from '../services/calendar.service';
import { ClockPickState, ClockPickerComponent } from './clock-picker.component';
const NUM_OF_MONTHS_TO_CREATE = 2;
@Component({
selector: 'moots-picker-modal',
animations: [
trigger('openClose', [
state(
'open',
style({
opacity: 1
})
),
state(
'closed',
style({
opacity: 0
})
),
transition('open => closed', [animate('0.4s')]),
transition('closed => open', [animate('0.5s')])
]),
trigger('enterAnimation', [
transition(':enter', [
style({ opacity: 0 }),
animate('500ms', style({ opacity: 1 }))
]),
transition(':leave', [
style({ opacity: 1 }),
animate('400ms', style({ opacity: 0 }))
])
]),
trigger('highlight', [
state(
'active',
style({
'box-shadow': '0 5px 15px 0 rgba(0, 0, 0, 0.5)',
border: 'solid 2px #f8e71c',
})
),
state(
'inactive',
style({
'box-shadow': '0 1px 3px 0 rgba(0, 0, 0, 0.5)',
border: 'solid 2px transparent',
})
),
transition('* => *', [animate('0.2s')]),
])
],
styleUrls: ['./calendar.modal.scss'],
templateUrl: './calendar.modal.html'
})
export class PickerModal implements OnInit, AfterViewInit {
GlobalPickState = GlobalPickState;
PickMode = PickMode;
@ViewChild(IonContent, { static: true })
content: IonContent;
@ViewChild('months', { static: true })
monthsEle: ElementRef;
@ViewChild('clockPicker')
clockPicker: ClockPickerComponent;
@HostBinding('class.ion-page')
ionPage = true;
@Input()
options: PickerModalOptions;
datesTemp: CalendarDay[] = [undefined, undefined];
timesTemp: moment.Moment[] = [undefined, undefined];
calendarMonths: CalendarMonth[];
step: number;
showYearPicker: boolean;
year: number;
years: number[];
_scrollLock = true;
_d: PickerModalOptions;
actualFirstTime: number;
pickState = GlobalPickState.BEGIN_DATE;
clockPickState = ClockPickState.HOUR;
constructor(
private _renderer: Renderer2,
public _elementRef: ElementRef,
public params: NavParams,
public modalCtrl: ModalController,
public ref: ChangeDetectorRef,
public calSvc: CalendarService
) { }
localeUses24HourTime(locale: string) {
return new Intl.DateTimeFormat(locale, {
hour: 'numeric'
}).formatToParts(new Date(2020, 0, 1, 13)).find(part => part.type === 'hour').value.length === 2;
}
is24Hours() {
return this._d.locale && this.localeUses24HourTime(this._d.locale);
}
onSelectChange(cstate: ClockPickState) {
this.clockPickState = cstate;
}
onClockValue(time: moment.Moment) {
if (this.isBegin(this.pickState)) {
this.timesTemp[0] = time;
} else {
this.timesTemp[1] = time;
}
this.preventInvalidRange();
switch (this.pickState) {
case (GlobalPickState.BEGIN_HOUR) : this.setPickState(GlobalPickState.BEGIN_MINUTE); break;
case (GlobalPickState.BEGIN_MINUTE) : this.setPickState(GlobalPickState.END_DATE); break;
case (GlobalPickState.END_HOUR) : this.setPickState(GlobalPickState.END_MINUTE); break;
}
}
preventInvalidRange() {
if (!this.datesTemp[1] || moment(this.datesTemp[0].time).day() === moment(this.datesTemp[1].time).day()) {
if (this.timesTemp[0].valueOf() > this.timesTemp[1].valueOf()) {
if (this.isBegin(this.pickState)) {
this.timesTemp[1] = this.timesTemp[0].clone().add(15, 'minutes');
} else {
const ampm = this.timesTemp[1].format('a');
if (this.is24Hours() || ampm === 'pm') {
this.timesTemp[0] = this.timesTemp[1].clone().subtract(15, 'minutes');
} else {
const f = this.timesTemp[1].format('hh:mm a');
const temp = moment(f.replace(ampm, 'pm'), 'hh:mm a');
this.timesTemp[1].hours(temp.hours());
this.timesTemp[1].minutes(temp.minutes());
}
}
}
}
}
getDateString(index: number) {
if (!this.datesTemp[index]) {
index--;
}
return moment(this.datesTemp[index].time).format('LL');
}
getTimeHours(index: number) {
return this.timesTemp[index]
.format(this.is24Hours() ? 'HH' : 'hh');
}
getTimeMinutes(index: number) {
return this.timesTemp[index].format('mm');
}
getAmPm(index: number) {
return this.timesTemp[index].format('A');
}
setPickState(pstate: GlobalPickState) {
this.pickState = pstate;
if (this.isHour(pstate)) {
this.clockPickState = ClockPickState.HOUR;
} else if (this.isMinute(pstate)) {
this.clockPickState = ClockPickState.MINUTE;
}
}
onClickStartDate() {
this.setPickState(GlobalPickState.BEGIN_DATE);
this.scrollToDate(moment(this.datesTemp[0].time));
}
onClickStartHour($event: Event) {
this.setPickState(GlobalPickState.BEGIN_HOUR);
if ($event) {
$event.stopPropagation();
}
}
onClickStartMin($event: Event) {
this.setPickState(GlobalPickState.BEGIN_MINUTE);
if ($event) {
$event.stopPropagation();
}
}
onClickEndDate() {
this.setPickState(GlobalPickState.END_DATE);
this.scrollToDate(moment(this.datesTemp[0].time));
}
onClickEndHour($event: Event) {
this.setPickState(GlobalPickState.END_HOUR);
if ($event) {
$event.stopPropagation();
}
}
onClickEndMin($event: Event) {
this.setPickState(GlobalPickState.END_MINUTE);
if ($event) {
$event.stopPropagation();
}
}
ngOnInit(): void {
this.init();
this.initDefaultDate();
}
ngAfterViewInit(): void {
this.findCssClass();
if (this._d.canBackwardsSelected) {
this.backwardsMonth();
}
}
init(): void {
this._d = this.calSvc.safeOpt(this.options);
this._d.showAdjacentMonthDay = false;
this.step = this._d.step;
if (this.step > this.calSvc.DEFAULT_STEP) {
this.step = this.calSvc.DEFAULT_STEP;
}
moment.locale(this._d.locale);
this.calendarMonths = this.calSvc.createMonthsByPeriod(
moment(this._d.from).valueOf(),
this.findInitMonthNumber(this._d.defaultScrollTo) + this.step,
this._d
);
this.setPickState(this._d.pickState);
}
initDefaultDate(): void {
const {
pickMode,
// defaultDate,
defaultDateRange,
defaultDates
} = this._d;
switch (pickMode) {
case PickMode.SINGLE:
// if (defaultDate) {
// this.datesTemp[0] = this.calSvc.createCalendarDay(
// this._getDayTime(defaultDate),
// this._d
// );
// this.datesTemp[1] = this.calSvc.createCalendarDay(
// this._getDayTime(defaultDate),
// this._d
// );
// }
// if ((nowMod.minutes() % 5) > 0) {
// nowMod.minutes(nowMod.minutes() - (nowMod.minutes() % 5));
// }
// this.timesTemp = [nowMod.format('hh:mm a'), nowMod.format('hh:mm a')];
break;
case PickMode.RANGE:
if (defaultDateRange) {
if (defaultDateRange.from) {
this.datesTemp[0] = this.calSvc.createCalendarDay(
this._getDayTime(defaultDateRange.from),
this._d
);
this.timesTemp[0] = moment(defaultDateRange.from);
}
if (defaultDateRange.to) {
this.datesTemp[1] = this.calSvc.createCalendarDay(
this._getDayTime(defaultDateRange.to),
this._d
);
if ((moment(defaultDateRange.from).valueOf() >= moment(defaultDateRange.to).valueOf())
) {
this.datesTemp[1] = undefined;
this.timesTemp[1] = this.timesTemp[0]
.clone()
.add(30, 'minutes');
} else {
this.timesTemp[1] = moment(defaultDateRange.to);
}
}
}
if (this.timesTemp[0].minutes() % 5 > 0) {
this.timesTemp[0].minutes(
this.timesTemp[0].minutes() -
(this.timesTemp[0].minutes() % 5)
);
}
if (this.timesTemp[1].minutes() % 5 > 0) {
this.timesTemp[1].minutes(
this.timesTemp[1].minutes() -
(this.timesTemp[1].minutes() % 5)
);
}
break;
case PickMode.MULTI:
if (defaultDates && defaultDates.length) {
this.datesTemp = defaultDates.map(e =>
this.calSvc.createCalendarDay(
this._getDayTime(e),
this._d
)
);
}
break;
default:
this.datesTemp = [undefined, undefined];
}
}
findCssClass(): void {
const { cssClass } = this._d;
if (cssClass) {
cssClass.split(' ').forEach((_class: string) => {
if (_class.trim() !== '') {
this._renderer.addClass(
this._elementRef.nativeElement,
_class
);
}
});
}
}
onChange(data: any): void {
// const { pickMode, autoDone } = this._d;
if (this.pickState === GlobalPickState.BEGIN_DATE) {
this.datesTemp[0] = data[0];
} else if (this.pickState === GlobalPickState.END_DATE) {
this.datesTemp[1] = data[1];
}
this._d.tapticConf.onCalendarSelect();
this.ref.detectChanges();
// if (pickMode !== pickModes.MULTI && autoDone && this.canDone()) {
// this.done();
// }
this.repaintDOM();
if (this.options.changeListener) {
this.options.changeListener(data);
}
if (this.canDone()) {
if (this.pickState === GlobalPickState.END_DATE) {
setTimeout(() => {
if (!this._d.fullday) {
this.onClickEndHour(undefined);
}
}, 200);
} else {
setTimeout(() => {
if (this._d.fullday) {
this.onClickEndDate();
} else {
this.onClickStartHour(undefined);
}
}, 200);
}
}
}
onCancel(): void {
this.modalCtrl.dismiss(undefined, 'cancel');
}
done(): void {
const { pickMode } = this._d;
this.modalCtrl.dismiss(
this.calSvc.wrapResult(this.datesTemp, this.timesTemp, pickMode),
'done'
);
}
canDone(): boolean {
return true;
}
nextMonth(event: any): void {
const len = this.calendarMonths.length;
const final = this.calendarMonths[len - 1];
const nextTime = moment(final.original.time)
.add(1, 'M')
.valueOf();
const rangeEnd = this._d.to ? moment(this._d.to).subtract(1, 'M') : 0;
if (
len <= 0 ||
(rangeEnd !== 0 && moment(final.original.time).isAfter(rangeEnd))
) {
event.target.disabled = true;
return;
}
this.calendarMonths.push(
...this.calSvc.createMonthsByPeriod(
nextTime,
NUM_OF_MONTHS_TO_CREATE,
this._d
)
);
event.target.complete();
this.repaintDOM();
}
backwardsMonth(): void {
const first = this.calendarMonths[0];
if (first.original.time <= 0) {
this._d.canBackwardsSelected = false;
return;
}
const firstTime = (this.actualFirstTime = moment(first.original.time)
.subtract(NUM_OF_MONTHS_TO_CREATE, 'M')
.valueOf());
this.calendarMonths.unshift(
...this.calSvc.createMonthsByPeriod(
firstTime,
NUM_OF_MONTHS_TO_CREATE,
this._d
)
);
this.ref.detectChanges();
this.repaintDOM();
}
scrollToDate(date: moment.Moment): void {
const defaultDateIndex = this.findInitMonthNumber(date);
const monthElement = this.monthsEle.nativeElement.children[
`month-${defaultDateIndex}`
];
const domElemReadyWaitTime = 300;
setTimeout(() => {
const defaultDateMonth = monthElement ? monthElement.offsetTop : 0;
if (defaultDateIndex !== -1 && defaultDateMonth !== 0) {
this.content.scrollByPoint(0, defaultDateMonth, 128);
}
}, domElemReadyWaitTime);
}
scrollToDefaultDate(): void {
this.scrollToDate(this._d.defaultScrollTo);
}
onScroll($event: any): void {
if (!this._d.canBackwardsSelected) {
return;
}
const { detail } = $event;
if (
detail.scrollTop <= 200 &&
detail.velocityY < 0 &&
this._scrollLock
) {
this.content.getScrollElement().then(scrollElem => {
this._scrollLock = !1;
const heightBeforeMonthPrepend = scrollElem.scrollHeight;
this.backwardsMonth();
setTimeout(() => {
const heightAfterMonthPrepend = scrollElem.scrollHeight;
this.content
.scrollByPoint(
0,
heightAfterMonthPrepend - heightBeforeMonthPrepend,
0
)
.then(() => {
this._scrollLock = !0;
});
}, 180);
});
}
}
/**
* In some older Safari versions (observed at Mac's Safari 10.0), there is an issue where style updates to
* shadowRoot descendants don't cause a browser repaint.
* See for more details: https://github.com/Polymer/polymer/issues/4701
*/
repaintDOM() {
return this.content.getScrollElement().then(scrollElem => {
// Update scrollElem to ensure that height of the container changes as Months are appended/prepended
scrollElem.style.zIndex = '2';
scrollElem.style.zIndex = 'initial';
// Update monthsEle to ensure selected state is reflected when tapping on a day
this.monthsEle.nativeElement.style.zIndex = '2';
this.monthsEle.nativeElement.style.zIndex = 'initial';
});
}
findInitMonthNumber(date: moment.Moment): number {
let startDate = this.actualFirstTime
? moment(this.actualFirstTime)
: moment(this._d.from);
const defaultScrollTo = moment(date);
const isAfter: boolean = defaultScrollTo.isAfter(startDate);
if (!isAfter) {
return -1;
}
if (this.showYearPicker) {
startDate = moment(new Date(this.year, 0, 1));
}
return defaultScrollTo.diff(startDate, 'month');
}
_getDayTime(date: any): number {
const mom = moment(date);
return moment(mom.format('YYYY-MM-DD')).valueOf();
}
_monthFormat(date: any): string {
return moment(date).format(this._d.monthFormat.replace(/y/g, 'Y'));
}
trackByIndex(index: number, momentDate: CalendarMonth): number {
return momentDate.original ? momentDate.original.time : index;
}
isBegin(pstate: GlobalPickState): boolean {
return pstate === GlobalPickState.BEGIN_DATE || pstate === GlobalPickState.BEGIN_HOUR || pstate === GlobalPickState.BEGIN_MINUTE;
}
isEnd(pstate: GlobalPickState): boolean {
return ! this.isBegin(pstate);
}
isDate(pstate: GlobalPickState): boolean {
return pstate === GlobalPickState.BEGIN_DATE || pstate === GlobalPickState.END_DATE;
}
isTime(pstate: GlobalPickState): boolean {
return ! this.isDate(pstate);
}
isHour(pstate: GlobalPickState): boolean {
return pstate === GlobalPickState.BEGIN_HOUR || pstate === GlobalPickState.END_HOUR;
}
isMinute(pstate: GlobalPickState): boolean {
return pstate === GlobalPickState.BEGIN_MINUTE || pstate === GlobalPickState.END_MINUTE;
}
}
|
moots-technology/moots-datetime-picker
|
src/moots-picker/calendar.model.ts
|
import { AnimationBuilder } from '@ionic/core';
import * as moment from 'moment';
export enum GlobalPickState {
BEGIN_DATE,
BEGIN_HOUR,
BEGIN_MINUTE,
END_DATE,
END_HOUR,
END_MINUTE
}
export enum PickMode {
SINGLE,
MULTI,
RANGE
}
export interface CalendarOriginal {
time: number;
date: moment.Moment;
year: number;
month: number;
firstWeek: number;
howManyDays: number;
}
export interface CalendarDay {
time: number;
isToday: boolean;
selected: boolean;
disable: boolean;
cssClass: string;
isLastMonth?: boolean;
isNextMonth?: boolean;
title?: string;
subTitle?: string;
marked?: boolean;
style?: {
title?: string;
subTitle?: string;
};
isFirst?: boolean;
isLast?: boolean;
}
export class CalendarMonth {
original: CalendarOriginal;
days: CalendarDay[];
}
export interface DayConfig {
date: moment.Moment;
marked?: boolean;
disable?: boolean;
title?: string;
subTitle?: string;
cssClass?: string;
}
export interface ModalOptions {
showBackdrop?: boolean;
backdropDismiss?: boolean;
enterAnimation?: AnimationBuilder;
leaveAnimation?: AnimationBuilder;
}
export interface PickerModalOptions extends CalendarOptions {
autoDone?: boolean;
format?: string;
cssClass?: string;
id?: string;
isSaveHistory?: boolean;
closeLabel?: string;
doneLabel?: string;
closeIcon?: boolean;
doneIcon?: boolean;
canBackwardsSelected?: boolean;
title?: string;
defaultScrollTo?: moment.Moment;
defaultDate?: moment.Moment;
defaultDates?: moment.Moment[];
defaultDateRange?: { from: moment.Moment; to?: moment.Moment } | undefined;
step?: number;
changeListener?: (data: any) => any;
locale?: string;
startLabel?: string;
endLabel?: string;
fulldayLabel?: string;
fullday?: boolean;
tapticConf?: TapticConfig;
}
export interface TapticConfig {
onClockHover?: () => void;
onClockSelect?: () => void;
onCalendarSelect?: () => void;
}
export interface CalendarOptions {
from?: moment.Moment;
to?: moment.Moment;
pickMode?: PickMode;
weekStart?: number;
disableWeeks?: number[];
weekdays?: string[];
monthFormat?: string;
color?: string;
defaultTitle?: string;
defaultSubtitle?: string;
daysConfig?: DayConfig[];
/**
* show last month & next month days fill six weeks
*/
showAdjacentMonthDay?: boolean;
pickState?: GlobalPickState;
}
export interface CalendarComponentOptions extends CalendarOptions {
showToggleButtons?: boolean;
showMonthPicker?: boolean;
monthPickerFormat?: string[];
}
export class CalendarResult {
time: number;
unix: number;
dateObj: Date;
string: string;
years: number;
months: number;
date: number;
}
export class CalendarComponentMonthChange {
oldMonth: CalendarResult;
newMonth: CalendarResult;
}
export type Colors = 'primary' | 'secondary' | 'danger' | 'light' | 'dark' | string;
export type CalendarComponentPayloadTypes = string | Date | number | {};
|
arminherling/Giphy-App-
|
Giphy App/src/app/app.module.ts
|
<filename>Giphy App/src/app/app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { HttpModule } from '@angular/http';
import { RouterModule } from '@angular/router';
import { AppComponent } from './app.component';
import { NavBarComponent } from './nav-bar/nav-bar.component';
import { HomeComponent } from './home/home.component';
import { TrendingComponent } from './trending/trending.component';
import { SearchComponent } from './search/search.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
import { ROUTES } from './app.routes';
import { GiphyService } from './giphy.service';
import { GifViewerComponent } from './gif-viewer/gif-viewer.component';
@NgModule({
declarations: [
AppComponent,
NavBarComponent,
HomeComponent,
TrendingComponent,
SearchComponent,
PageNotFoundComponent,
GifViewerComponent
],
imports: [
BrowserModule,
FormsModule,
HttpModule,
RouterModule.forRoot(ROUTES)
],
providers: [
GiphyService
],
bootstrap: [AppComponent]
})
export class AppModule { }
|
ChainSafe/ganache-core
|
src/packages/core/index.ts
|
<reponame>ChainSafe/ganache-core<gh_stars>1-10
import { Providers } from "@ganache/flavors";
import ConnectorLoader from "./src/connector-loader";
import { ProviderOptions, ServerOptions } from "./src/options";
import Server from "./src/server";
export { Status } from "./src/server";
export { ProviderOptions, ServerOptions, serverDefaults } from "./src/options";
export default {
/**
* Creates a Ganache server instance that creates and
* serves an underlying Ganache provider. Initialization
* doesn't begin until `server.listen(...)` is called.
* `server.listen(...)` returns a promise that resolves
* when initialization is finished.
*
* @param options Configuration options for the server;
* `options` includes provider based options as well.
* @returns A provider instance for the flavor
* `options.flavor` which defaults to `ethereum`.
*/
server: (options?: ServerOptions) => new Server(options),
/**
* Initializes a Web3 provider for a Ganache instance.
* This function starts an asynchronous task, but does not
* finish it by the time the function returns. Listen to
* `provider.on("connect", () => {...})` or wait for
* `await provider.once("connect")` for initialization to
* finish. You may start sending requests to the provider
* before initialization finishes however; these requests
* will start being consumed after initialization finishes.
*
* @param options Configuration options for the provider.
* @returns A provider instance for the flavor
* `options.flavor` which defaults to `ethereum`.
*/
provider: (options?: ProviderOptions): Providers => {
const connector = ConnectorLoader.initialize(options);
return connector.provider;
}
};
|
ChainSafe/ganache-core
|
src/packages/core/src/connector-loader.ts
|
import { utils } from "@ganache/utils";
import {
ConnectorsByName,
DefaultFlavor,
DefaultOptionsByName
} from "@ganache/flavors";
import { Options as ProviderOptions } from "@ganache/flavors";
import { hasOwn } from "@ganache/utils/src/utils";
import { Base, Definitions } from "@ganache/options";
/**
* Loads the connector specified by the given `flavor`
*/
export default {
initialize: (
providerOptions: ProviderOptions = {
flavor: DefaultFlavor,
chain: { asyncRequestProcessing: true }
}
) => {
const flavor = providerOptions.flavor || DefaultFlavor;
// Set up our request coordinator to either use FIFO or or async request processing.
// The RequestCoordinator _can_ be used to coordinate the number of requests being processed, but we don't use it
// for that (yet), instead of "all" (0) or just 1 as we are doing here:
const asyncRequestProcessing =
"chain" in providerOptions
? providerOptions.chain.asyncRequestProcessing
: (providerOptions as any).asyncRequestProcessing;
const requestCoordinator = new utils.RequestCoordinator(
asyncRequestProcessing ? 0 : 1
);
// The Executor is responsible for actually executing the method on the chain/API.
// It performs some safety checks to ensure "safe" method execution before passing it
// to a RequestCoordinator.
const executor = new utils.Executor(requestCoordinator);
const connector = new ConnectorsByName[flavor](
providerOptions as any,
executor
);
// Purposely not awaiting on this to prevent a breaking change
// to the `Ganache.provider()` method
connector.initialize();
// The request coordinator is initialized in a "paused" state; when the provider is ready we unpause.
// This lets us accept queue requests before we've even fully initialized.
connector.on("ready", requestCoordinator.resume);
return connector;
}
};
|
ChainSafe/ganache-core
|
src/chains/ethereum/ethereum/src/connector.ts
|
import Emittery from "emittery";
import EthereumApi from "./api";
import { JsonRpcTypes, types, utils } from "@ganache/utils";
import EthereumProvider from "./provider";
import { RecognizedString, WebSocket, HttpRequest } from "uWebSockets.js";
import { CodedError, ErrorCodes } from "@ganache/ethereum-utils";
import {
EthereumProviderOptions,
EthereumLegacyOptions
} from "@ganache/ethereum-options";
export type ProviderOptions = EthereumProviderOptions | EthereumLegacyOptions;
export type Provider = EthereumProvider;
export const Provider = EthereumProvider;
function isHttp(
connection: HttpRequest | WebSocket
): connection is HttpRequest {
return connection.constructor.name === "uWS.HttpRequest";
}
export class Connector
extends Emittery.Typed<undefined, "ready" | "close">
implements
types.Connector<
EthereumApi,
JsonRpcTypes.Request<EthereumApi> | JsonRpcTypes.Request<EthereumApi>[],
JsonRpcTypes.Response
> {
#provider: EthereumProvider;
get provider() {
return this.#provider;
}
constructor(
providerOptions: ProviderOptions = null,
executor: utils.Executor
) {
super();
this.#provider = new EthereumProvider(
providerOptions,
executor
);
}
async initialize() {
await this.#provider.initialize();
// no need to wait for #provider.once("connect") as the initialize()
// promise has already accounted for that after the promise is resolved
await this.emit("ready");
}
parse(message: Buffer) {
try {
return JSON.parse(message) as JsonRpcTypes.Request<EthereumApi>;
} catch (e) {
throw new CodedError(e.message, ErrorCodes.PARSE_ERROR);
}
}
handle(
payload:
| JsonRpcTypes.Request<EthereumApi>
| JsonRpcTypes.Request<EthereumApi>[],
connection: HttpRequest | WebSocket
) {
if (Array.isArray(payload)) {
// handle batch transactions
const promises = payload.map(payload =>
this.#handle(payload, connection)
.then(({ value }) => value)
.catch(e => e)
);
return Promise.resolve({ value: Promise.all(promises) });
} else {
return this.#handle(payload, connection);
}
}
#handle = (
payload: JsonRpcTypes.Request<EthereumApi>,
connection: HttpRequest | WebSocket
) => {
const method = payload.method;
if (method === "eth_subscribe") {
if (isHttp(connection)) {
return Promise.reject(
new CodedError(
"notifications not supported",
ErrorCodes.METHOD_NOT_SUPPORTED
)
);
}
}
const params = payload.params as Parameters<EthereumApi[typeof method]>;
return this.#provider._requestRaw({ method, params });
};
format(
result: any,
payload: JsonRpcTypes.Request<EthereumApi>
): RecognizedString;
format(
results: any[],
payloads: JsonRpcTypes.Request<EthereumApi>[]
): RecognizedString;
format(
results: any | any[],
payload:
| JsonRpcTypes.Request<EthereumApi>
| JsonRpcTypes.Request<EthereumApi>[]
): RecognizedString {
if (Array.isArray(payload)) {
return JSON.stringify(
payload.map((payload, i) => {
const result = results[i];
if (result instanceof Error) {
return JsonRpcTypes.Error(payload.id, result as any);
} else {
return JsonRpcTypes.Response(payload.id, result);
}
})
);
} else {
const json = JsonRpcTypes.Response(payload.id, results);
return JSON.stringify(json);
}
}
formatError(
error: Error & { code: number },
payload: JsonRpcTypes.Request<EthereumApi>
): RecognizedString {
const json = JsonRpcTypes.Error(
payload && payload.id ? payload.id : null,
error
);
return JSON.stringify(json);
}
close() {
return this.#provider.disconnect();
}
}
|
nextriot/react-native-retween
|
src/animations/runTiming.ts
|
<reponame>nextriot/react-native-retween
import {
IAnimationConfig,
TimingTweenAnimation,
updateStateProc,
} from './../common';
import A, { Easing } from 'react-native-reanimated';
export interface TimingAnimationConfig {
duration: number;
easing?: A.EasingFunction;
}
const timingProc = A.proc((
clock: A.Clock,
// state
finished: A.Value<number>,
position: A.Value<number>,
time: A.Value<number>,
frameTime: A.Value<number>,
// config
toValue: A.Adaptable<number>,
duration: A.Adaptable<number>,
) =>
A.timing(
clock,
{
finished,
position,
time,
frameTime,
},
{
toValue,
duration,
easing: Easing.linear,
},
),
);
function timing(
clock: A.Clock,
state: {
finished: A.Value<number>;
frameTime: A.Value<number>;
position: A.Value<number>;
time: A.Value<number>;
},
config: {
toValue: A.Adaptable<number>;
duration: A.Adaptable<number>;
easing: A.EasingFunction;
},
) {
return timingProc(
clock,
state.finished,
state.position,
state.time,
state.frameTime,
config.toValue,
config.duration,
);
// return A.timing(clock, state, config);
}
export const runTiming = (
{ clock, oppositeClock, value, dest, onFinish }: IAnimationConfig,
props: TimingTweenAnimation<any>,
) => {
const state = {
finished: new A.Value(0),
position: new A.Value(0),
time: new A.Value(0),
frameTime: new A.Value(0),
};
const config = {
duration: props.timing.duration,
toValue: new A.Value(0),
easing: props.timing.easing || Easing.inOut(Easing.ease),
};
return A.block([
// stops opposite (opposite direction) clock
A.cond(
A.clockRunning(oppositeClock),
A.stopClock(oppositeClock),
0,
),
A.cond(A.clockRunning(clock), 0, [
updateStateProc(
value,
dest,
state.finished,
state.position,
state.time,
state.frameTime,
config.toValue,
),
A.startClock(clock),
]),
timing(clock, state, config),
A.cond(
state.finished,
// @ts-ignore
A.block([A.stopClock(clock), onFinish]),
),
A.set(value, state.position),
]);
};
|
nextriot/react-native-retween
|
src/useTween.ts
|
<gh_stars>10-100
import { useMemo, useState, useCallback } from 'react';
import A from 'react-native-reanimated';
import {
AnimationState,
AnimationInputValues,
TweenAnimationProps,
getAnimationRunner,
interpolate,
bInterpolateColor,
} from './common';
import { isRGB, isNumber } from './utils/checkers';
export type ReanimatedValues<T> = { [K in keyof T]: A.Value<number> };
export interface AnimationBag<T extends AnimationInputValues> {
transition: A.Value<number>;
values: ReanimatedValues<T>;
play(backward?: boolean): void;
stop(): void;
}
interface Animation<T extends AnimationInputValues>
extends AnimationBag<T> {
animation: A.Node<any>;
}
function generateTweenAnimation<T extends AnimationInputValues>(
props: TweenAnimationProps<T>,
): Animation<T> {
const animationState = new A.Value<AnimationState>(
AnimationState.START_POINT,
);
const keys = Object.keys(props.from);
const masterValue = new A.Value(0);
const inputRange: [number, number] = [0, 1];
const values: ReanimatedValues<T> = keys.reduce(
(acc, current) => {
const from = props.from[current];
const to = props.to[current];
// if we are interpolating colors
if (isRGB(from) && isRGB(to)) {
acc[current] = bInterpolateColor(masterValue, {
inputRange,
outputRange: [from, to],
});
// currently only numbers are allowed
} else if (isNumber(from) && isNumber(to)) {
acc[current] = interpolate(masterValue, {
inputRange,
outputRange: [from, to],
});
} else {
throw new Error(
`Unsupported value 'from: ${from}, to: ${to}' of prop ${current}`,
);
}
return acc;
},
{} as any,
);
// returns timing or spring animation runner based on config
const runAnimation = getAnimationRunner<T>(props);
const forwardAnimationClock = new A.Clock();
const backwardAnimationClock = new A.Clock();
const animation = A.block([
A.cond(
A.eq(animationState, AnimationState.PLAY_FORWARD),
// run all the forward animations
runAnimation(
{
clock: forwardAnimationClock,
oppositeClock: backwardAnimationClock,
value: masterValue,
dest: 1,
onFinish: A.set(animationState, AnimationState.END_POINT),
},
props,
),
// 0,
),
A.cond(
A.eq(animationState, AnimationState.PLAY_BACKWARD),
// run all the backward animations
runAnimation(
{
clock: backwardAnimationClock,
oppositeClock: forwardAnimationClock,
value: masterValue,
dest: 0,
onFinish: A.set(animationState, AnimationState.START_POINT),
},
props,
),
),
]);
function play(backward?: boolean) {
animationState.setValue(
backward
? AnimationState.PLAY_BACKWARD
: AnimationState.PLAY_FORWARD,
);
}
function stop() {
animationState.setValue(AnimationState.START_POINT);
}
return {
animation,
play,
stop,
values,
transition: masterValue,
};
}
function useReset() {
const [count, setCount] = useState<number>(0);
const reset = useCallback<any>(() => {
setCount((val) => val + 1);
}, []);
return [count, reset];
}
export function useTween<TValues extends AnimationInputValues>(
config: () => TweenAnimationProps<TValues>,
deps: any[] = [],
): AnimationBag<TValues> {
// TODO: Find better way to stop/reset animation
const [count, stop] = useReset();
const depsToUse = [...deps, count];
const { play, values, animation, transition } = useMemo<
Animation<TValues>
>(() => {
const animation = config();
return generateTweenAnimation<TValues>(animation);
}, depsToUse);
A.useCode(animation, depsToUse);
return {
play,
stop,
values,
transition,
};
}
|
nextriot/react-native-retween
|
src/common.ts
|
<filename>src/common.ts
import A from 'react-native-reanimated';
import {
TimingAnimationConfig,
runTiming,
} from './animations/runTiming';
import {
SpringAnimationConfig,
runSpring,
} from './animations/runSpring';
export interface RGBColor {
r: number;
g: number;
b: number;
}
export enum AnimationState {
START_POINT = 0,
PLAY_FORWARD = 1,
END_POINT = 2,
PLAY_BACKWARD = 3,
}
export interface IAnimationConfig {
clock: A.Clock;
oppositeClock: A.Clock;
value: A.Value<number>;
dest: A.Adaptable<number>;
onFinish?: A.Node<number>;
}
export type AnimatedInputValue = number | RGBColor;
export interface AnimationInputValues {
[key: string]: AnimatedInputValue;
}
export interface AnimationValues {
[key: string]: A.Value<number>;
}
export interface TimingTweenAnimation<T> {
timing: TimingAnimationConfig;
from: T;
to: T;
}
export interface TweenAnimationValues {
from: AnimationValues;
to: AnimationValues;
}
export interface SpringTweenAnimation<T> {
spring: SpringAnimationConfig;
from: T;
to: T;
}
export type TweenAnimationProps<T> =
| TimingTweenAnimation<T>
| SpringTweenAnimation<T>; //| KeyframesAnimation<T>;
export function isSpring<T>(
param: TweenAnimationProps<T>,
): param is SpringTweenAnimation<T> {
return (
typeof (param as SpringTweenAnimation<T>).spring !== 'undefined'
);
}
export function isTiming<T>(
param: TweenAnimationProps<T>,
): param is TimingTweenAnimation<T> {
return (
typeof (param as TimingTweenAnimation<T>).timing !== 'undefined'
);
}
type AnimationRunner = (
config: IAnimationConfig,
// FIXME: Find a better type
props: any,
) => A.Node<number>;
export function getAnimationRunner<T>(
props: TweenAnimationProps<T>,
): AnimationRunner {
if (isTiming(props)) {
return runTiming;
} else if (isSpring(props)) {
return runSpring;
} else {
throw new Error('Unsupported animation');
}
}
export const updateStateProc = A.proc((
// custom
value: A.Value<number>,
dest: A.Adaptable<number>,
// state
finished: A.Value<number>,
position: A.Value<number>,
time: A.Value<number>,
frameTime: A.Value<number>,
// config
toValue: A.Value<number>,
) =>
A.block([
A.set(finished, 0),
A.set(time, 0),
A.set(position, value),
A.set(frameTime, 0),
A.set(toValue, dest),
]),
);
const interpolateProc = A.proc(
(
value: A.Value<number>,
input1: A.Adaptable<number>,
input2: A.Adaptable<number>,
output1: A.Adaptable<number>,
output2: A.Adaptable<number>,
) =>
A.interpolate(value, {
inputRange: [input1, input2],
outputRange: [output1, output2],
extrapolate: A.Extrapolate.EXTEND,
}),
);
export function interpolate(
value: A.Value<number>,
config: {
inputRange: [number, number];
outputRange: [number, number];
},
) {
return interpolateProc(
value,
config.inputRange[0],
config.inputRange[1],
config.outputRange[0],
config.outputRange[1],
);
}
export const bInterpolateColorProc = A.proc(
(
animationValue: A.Value<number>,
input1: A.Adaptable<number>,
input2: A.Adaptable<number>,
r1: A.Adaptable<number>,
r2: A.Adaptable<number>,
g1: A.Adaptable<number>,
g2: A.Adaptable<number>,
b1: A.Adaptable<number>,
b2: A.Adaptable<number>,
) =>
A.color(
A.round(
A.interpolate(animationValue, {
inputRange: [input1, input2],
outputRange: [r1, r2],
extrapolate: A.Extrapolate.EXTEND,
}),
),
A.round(
A.interpolate(animationValue, {
inputRange: [input1, input2],
outputRange: [g1, g2],
extrapolate: A.Extrapolate.EXTEND,
}),
),
A.round(
A.interpolate(animationValue, {
inputRange: [input1, input2],
outputRange: [b1, b2],
extrapolate: A.Extrapolate.EXTEND,
}),
),
),
);
export const bInterpolateColor = (
value: A.Adaptable<number>,
config: {
inputRange: [number, number];
outputRange: [RGBColor, RGBColor];
},
) =>
bInterpolateColorProc(
value,
config.inputRange[0],
config.inputRange[1],
config.outputRange[0].r,
config.outputRange[1].r,
config.outputRange[0].g,
config.outputRange[1].g,
config.outputRange[0].b,
config.outputRange[1].b,
);
|
nextriot/react-native-retween
|
src/utils/checkers.ts
|
<gh_stars>10-100
import { AnimatedInputValue, RGBColor } from 'src/common';
export function isNumber(v: any): v is number {
return typeof v === 'number';
}
export function isRGB(value: AnimatedInputValue): value is RGBColor {
const color = value as RGBColor;
return (
typeof color === 'object' &&
isNumber(color.r) &&
isNumber(color.g) &&
isNumber(color.b)
);
}
|
nextriot/react-native-retween
|
example/App.tsx
|
import React from 'react';
import AccordionScreen from './screens/Accordion/AccordionScreen';
import { createStackNavigator } from 'react-navigation-stack';
import { createAppContainer } from 'react-navigation';
import { HomeScreen } from './screens/HomeScreen/HomeScreen';
import { BasicScreen } from './screens/Basic/BasicScreen';
export const routes = {
Accordion: AccordionScreen,
Basic: BasicScreen,
};
const StackNavigator = createStackNavigator(
{
Home: HomeScreen,
...routes,
},
{
initialRouteName: 'Home',
},
);
const Navigator = createAppContainer(StackNavigator);
function App() {
return <Navigator />;
}
export default App;
|
nextriot/react-native-retween
|
example/screens/Accordion/AccordionScreen.tsx
|
<reponame>nextriot/react-native-retween<filename>example/screens/Accordion/AccordionScreen.tsx
import React from 'react';
import { Text, ScrollView } from 'react-native';
import { StyleSheet } from 'react-native';
import { List, List as ListModel } from './List';
import { FlatList } from 'react-native-gesture-handler';
const s = StyleSheet.create({
container: {
backgroundColor: '#f4f4f6',
},
innerContainer: {
padding: 16,
},
title: {
fontSize: 32,
fontWeight: 'bold',
},
});
const list: ListModel = {
name: 'Total Points',
items: [
{ name: '<NAME>', points: '$3.45' },
{ name: '<NAME>', points: '$3.45' },
{ name: '<NAME>', points: '$3.45' },
{ name: '<NAME>', points: '$3.45' },
{ name: '<NAME>', points: '$2.56' },
],
};
const data: ListModel[] = Array(5).fill(list);
function AccordionScreen() {
return (
<FlatList
style={s.container}
contentContainerStyle={s.innerContainer}
ListHeaderComponent={() => <Text style={s.title}>Markets</Text>}
data={data}
keyExtractor={(_, index) => String(index)}
renderItem={({ item }) => <List list={item} />}
/>
);
}
export default AccordionScreen;
|
nextriot/react-native-retween
|
example/screens/Accordion/List.tsx
|
import React, { RefObject, useState } from 'react';
import {
StyleSheet,
Text,
TouchableWithoutFeedback,
} from 'react-native';
import Animated from 'react-native-reanimated';
import { Chevron } from './Chevron';
import Item, { ListItem } from './ListItem';
import { useTweenToggle } from '../../../src';
const styles = StyleSheet.create({
container: {
marginTop: 16,
backgroundColor: 'white',
padding: 16,
borderTopLeftRadius: 8,
borderTopRightRadius: 8,
flexDirection: 'row',
alignItems: 'center',
justifyContent: 'space-between',
},
title: {
fontSize: 16,
fontWeight: 'bold',
},
items: {
overflow: 'hidden',
},
});
export interface List {
name: string;
items: ListItem[];
}
interface ListProps {
list: List;
}
export function List({ list }: ListProps) {
const [open, setOpen] = useState(false);
const { values, transition } = useTweenToggle(
() => ({
spring: {
mass: 0.1,
stiffness: 50,
},
from: {
opacity: 0,
height: 0,
bottomRadius: 8,
rotateZ: 0,
chevronBg: { r: 82, g: 82, b: 81 },
},
to: {
opacity: 1,
height: 54 * list.items.length,
bottomRadius: 0,
rotateZ: Math.PI,
chevronBg: { r: 228, g: 86, b: 69 },
},
}),
open,
);
const { bottomRadius, chevronBg, rotateZ, ...restValues } = values;
return (
<>
<TouchableWithoutFeedback
onPress={() => {
setOpen((prev) => !prev);
}}
>
<Animated.View
style={[
styles.container,
{
borderBottomLeftRadius: bottomRadius,
borderBottomRightRadius: bottomRadius,
},
]}
>
<Text style={styles.title}>Total Points</Text>
<Chevron {...{ transition, chevronBg, rotateZ }} />
</Animated.View>
</TouchableWithoutFeedback>
<Animated.View style={[styles.items, restValues]}>
{list.items.map((item, key) => (
<Item
{...{ item, key }}
isLast={key === list.items.length - 1}
/>
))}
</Animated.View>
</>
);
}
|
nextriot/react-native-retween
|
example/screens/Basic/BasicScreen.tsx
|
import React, { useEffect, useState } from 'react';
import {
StyleSheet,
View,
Dimensions,
FlatList,
Button,
} from 'react-native';
import Animated from 'react-native-reanimated';
import { useTween } from '../../../src';
const { width: windowWidth } = Dimensions.get('window');
const colors = {
red: '#e74c3c',
white: 'white',
green: '#2ecc71',
};
const s = StyleSheet.create({
scroll: {
paddingVertical: 20,
},
animationContainer: {
flex: 1,
justifyContent: 'center',
// alignItems: 'center',
},
animatedView: {
backgroundColor: colors.red,
},
row: {
flexDirection: 'row',
alignSelf: 'center',
},
});
function TweenExample() {
const { play, values, stop } = useTween(() => ({
timing: {
duration: 400,
},
from: {
width: 50,
height: 50,
left: 20,
borderRadius: 0,
},
to: {
width: 200,
height: 200,
left: windowWidth - 20 - 200,
borderRadius: 2,
},
}));
const [backward, setBackward] = React.useState(false);
function onPlay() {
play(backward);
setBackward((val) => !val);
}
function onStop() {
stop();
setBackward(false);
}
return (
<View style={s.animationContainer}>
<View style={s.row}>
<Button onPress={onPlay} title="Toggle animation" />
<Button onPress={onStop} title="Stop" />
</View>
<Animated.View style={[s.animatedView, values]} />
</View>
);
}
const ANIMATION_COUNT = 10;
export function BasicScreen() {
const [show, setShow] = React.useState(false);
// performance test
const range = Array.from(new Array(ANIMATION_COUNT));
if (!show) {
return (
<View
style={{
flex: 1,
justifyContent: 'center',
alignItems: 'center',
}}
>
<Button onPress={() => setShow(true)} title="Show" />
</View>
);
}
return (
<FlatList
data={range}
initialNumToRender={ANIMATION_COUNT}
// maxToRenderPerBatch={ANIMATION_COUNT}
contentContainerStyle={s.scroll}
renderItem={() => <TweenExample />}
keyExtractor={(_, i) => i.toString()}
/>
);
}
|
nextriot/react-native-retween
|
src/animations/runSpring.ts
|
<reponame>nextriot/react-native-retween<filename>src/animations/runSpring.ts
import {
IAnimationConfig,
SpringTweenAnimation,
updateStateProc,
} from './../common';
import A from 'react-native-reanimated';
export type SpringConfig = {
damping: number;
mass: number;
stiffness: number;
restSpeedThreshold: number;
restDisplacementThreshold: number;
overshootClamping: boolean;
};
export interface SpringAnimationConfig
extends Partial<SpringConfig> {}
const springProc = A.proc(
(
finished: A.Value<number>,
velocity: A.Value<number>,
position: A.Value<number>,
time: A.Value<number>,
prevPosition: A.Value<number>,
toValue: A.Adaptable<number>,
damping: A.Adaptable<number>,
mass: A.Adaptable<number>,
stiffness: A.Adaptable<number>,
overshootClamping: A.Adaptable<number>,
restSpeedThreshold: A.Adaptable<number>,
restDisplacementThreshold: A.Adaptable<number>,
clock: A.Clock,
) =>
A.spring(
clock,
{
finished,
velocity,
position,
time,
// @ts-ignore
prevPosition,
},
{
toValue,
damping,
mass,
stiffness,
overshootClamping,
restDisplacementThreshold,
restSpeedThreshold,
},
),
);
type AnimatedSpringConfig = {
damping: A.Adaptable<number>;
mass: A.Adaptable<number>;
stiffness: A.Adaptable<number>;
restSpeedThreshold: A.Adaptable<number>;
restDisplacementThreshold: A.Adaptable<number>;
overshootClamping: A.Adaptable<number>;
};
const defaultConfig = A.SpringUtils.makeDefaultConfig();
function transformSpringConfigToAnimatedValues(
config: Partial<SpringConfig>,
): AnimatedSpringConfig {
return {
damping: config.damping
? new A.Value(config.damping)
: defaultConfig.damping,
stiffness: config.stiffness
? new A.Value(config.stiffness)
: defaultConfig.stiffness,
mass: config.mass ? new A.Value(config.mass) : defaultConfig.mass,
restDisplacementThreshold: config.restDisplacementThreshold
? new A.Value(config.restDisplacementThreshold)
: defaultConfig.restDisplacementThreshold,
restSpeedThreshold: config.restSpeedThreshold
? new A.Value(config.restSpeedThreshold)
: defaultConfig.restSpeedThreshold,
overshootClamping: new A.Value(config.overshootClamping ? 1 : 0),
};
}
interface RunSpringAnimationConfig extends AnimatedSpringConfig {
toValue: A.Adaptable<number>;
}
// @ts-ignore
function spring(
clock: A.Clock,
state: {
finished: A.Value<number>;
velocity: A.Value<number>;
position: A.Value<number>;
time: A.Value<number>;
},
config: RunSpringAnimationConfig,
) {
return springProc(
state.finished,
state.velocity,
state.position,
state.time,
new A.Value(0),
config.toValue,
config.damping,
config.mass,
config.stiffness,
config.overshootClamping,
config.restSpeedThreshold,
config.restDisplacementThreshold,
clock,
);
}
export const runSpring = (
{ clock, oppositeClock, value, dest, onFinish }: IAnimationConfig,
props: SpringTweenAnimation<any>,
) => {
const state = {
finished: new A.Value(0),
position: new A.Value(0),
time: new A.Value(0),
velocity: new A.Value(0),
};
const config = {
...transformSpringConfigToAnimatedValues(props.spring),
toValue: dest,
};
return A.block([
// stops opposite (opposite direction) clock
A.cond(
A.clockRunning(oppositeClock),
A.stopClock(oppositeClock),
0,
),
A.cond(A.clockRunning(clock), 0, [
updateStateProc(
value,
dest,
state.finished,
state.position,
state.time,
state.velocity,
config.toValue,
),
A.startClock(clock),
]),
spring(clock, state, config),
A.cond(
state.finished,
// @ts-ignore
A.block([A.stopClock(clock), onFinish]),
),
A.set(value, state.position),
]);
};
|
nextriot/react-native-retween
|
src/useTweenToggle.ts
|
<gh_stars>10-100
import A from 'react-native-reanimated';
import { TweenAnimationProps, AnimationInputValues } from './common';
import { useTween, ReanimatedValues } from './useTween';
import { useEffect, useRef, useCallback } from 'react';
export interface ToggleAnimationBag<T extends AnimationInputValues> {
transition: A.Value<number>;
values: ReanimatedValues<T>;
reset(): void;
}
export function useTweenToggle<T extends AnimationInputValues>(
config: () => TweenAnimationProps<T>,
toggleValue: boolean,
): ToggleAnimationBag<T> {
const mount = useRef(false);
const backward = useRef(false);
const { play, values, stop, transition } = useTween<T>(config);
useEffect(() => {
if (!mount.current) {
mount.current = true;
} else {
play(backward.current);
backward.current = !backward.current;
}
}, [toggleValue]);
const onStop = useCallback(() => {
stop();
backward.current = false;
}, []);
return {
values,
reset: onStop,
transition,
};
}
|
nextriot/react-native-retween
|
example/screens/HomeScreen/HomeScreen.tsx
|
import React from 'react';
import { View, Text, StyleSheet } from 'react-native';
import { NavigationStackScreenProps } from 'react-navigation-stack';
import { TouchableOpacity } from 'react-native';
import Icon from 'react-native-vector-icons/Ionicons';
import { routes } from '../../App';
import { FlatList } from 'react-native';
import { NavigationStackOptions } from 'react-navigation-stack';
const s = StyleSheet.create({
listItem: {
height: 52,
justifyContent: 'space-between',
alignItems: 'center',
paddingHorizontal: 16,
flexDirection: 'row',
},
text: {
fontSize: 19,
fontWeight: '500',
},
separator: {
height: StyleSheet.hairlineWidth,
backgroundColor: '#cccccc',
},
});
interface HomeProps extends NavigationStackScreenProps {}
export function HomeScreen({ navigation }: HomeProps) {
const list = Object.keys(routes);
return (
<FlatList
data={list}
keyExtractor={(item, index) => item + index}
renderItem={({ item }) => (
<TouchableOpacity
style={s.listItem}
onPress={() => navigation.navigate(item)}
>
<Text style={s.text}>{item}</Text>
<Icon name="ios-arrow-forward" color="black" size={24} />
</TouchableOpacity>
)}
ItemSeparatorComponent={() => <View style={s.separator} />}
ListFooterComponent={() => <View style={s.separator} />}
/>
);
}
HomeScreen.navigationOptions = {
title: 'Examples',
} as NavigationStackOptions;
|
nextriot/react-native-retween
|
example/screens/Accordion/Chevron.tsx
|
<gh_stars>10-100
import React from 'react';
import { StyleSheet, View } from 'react-native';
import Icon from 'react-native-vector-icons/Ionicons';
import Animated from 'react-native-reanimated';
import { bInterpolateColor } from 'react-native-redash';
const size = 30;
const s = StyleSheet.create({
container: {
height: size,
width: size,
borderRadius: size / 2,
justifyContent: 'center',
alignItems: 'center',
},
icon: {
height: 24,
width: 24,
justifyContent: 'center',
alignItems: 'center',
textAlignVertical: 'center',
textAlign: 'center',
},
});
interface ChevronProps {
chevronBg: Animated.Value<number>;
rotateZ: Animated.Value<number>;
}
export function Chevron({ chevronBg, rotateZ }: ChevronProps) {
return (
<Animated.View
// @ts-ignore
style={[
{ transform: [{ rotateZ }], backgroundColor: chevronBg },
s.container,
]}
>
<Icon
style={s.icon}
name="ios-arrow-down"
color="white"
size={24}
/>
</Animated.View>
);
}
|
nextriot/react-native-retween
|
src/index.ts
|
<reponame>nextriot/react-native-retween
import { TweenAnimationProps } from './common';
import { useTween } from './useTween';
import { useTweenToggle } from './useTweenToggle';
export { useTween, TweenAnimationProps, useTweenToggle };
|
YourBrainEatsYou/adventofcode2021
|
src/challenges/day-15/challenge-29.ts
|
<reponame>YourBrainEatsYou/adventofcode2021
import Day15 from './day-15';
import { Node } from './interfaces/Node';
export default class Challenge29 extends Day15 {
createMap(): Node[][] {
const map = [];
for (let yIndex = 0; yIndex < this.input.length; yIndex += 1) {
map[yIndex] = [];
for (let xIndex = 0; xIndex < this.input[0].length; xIndex += 1) {
map[yIndex][xIndex] = {
id: xIndex.toString() + '-' + yIndex.toString(),
position: {
x: xIndex,
y: yIndex,
},
g: 0,
h: 0,
f: 0,
distance: yIndex === 0 && xIndex === 0 ? 0 : this.input[yIndex][xIndex],
parent: null,
};
}
}
return map;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.