feat: Scoped Packages (#7911)

* chore: move tns-core-modules to nativescript-core

* chore: preparing compat generate script

* chore: add missing definitions

* chore: no need for http-request to be private

* chore: packages chore

* test: generate tests for tns-core-modules

* chore: add anroid module for consistency

* chore: add .npmignore

* chore: added privateModulesWhitelist

* chore(webpack): added bundle-entry-points

* chore: scripts

* chore: tests changed to use @ns/core

* test: add scoped-packages test project

* test: fix types

* test: update test project

* chore: build scripts

* chore: update build script

* chore: npm scripts cleanup

* chore: make the compat pgk work with old wp config

* test: generate diff friendly tests

* chore: create barrel exports

* chore: move files after rebase

* chore: typedoc config

* chore: compat mode

* chore: review of barrels

* chore: remove tns-core-modules import after rebase

* chore: dev workflow setup

* chore: update developer-workflow

* docs: experiment with API extractor

* chore: api-extractor and barrel exports

* chore: api-extractor configs

* chore: generate d.ts rollup with api-extractor

* refactor: move methods inside Frame

* chore: fic tests to use Frame static methods

* refactor: create Builder class

* refactor: use Builder class in tests

* refactor: include Style in ui barrel

* chore: separate compat build script

* chore: fix tslint errors

* chore: update NATIVESCRIPT_CORE_ARGS

* chore: fix compat pack

* chore: fix ui-test-app build with linked modules

* chore: Application, ApplicationSettings, Connectivity and Http

* chore: export Trace, Profiling and Utils

* refactor: Static create methods for ImageSource

* chore: fix deprecated usages of ImageSource

* chore: move Span and FormattedString to ui

* chore: add events-args and ImageSource to index files

* chore: check for CLI >= 6.2 when building for IOS

* chore: update travis build

* chore: copy Pod file to compat package

* chore: update error msg ui-tests-app

* refactor: Apply suggestions from code review

Co-Authored-By: Martin Yankov <m.i.yankov@gmail.com>

* chore: typings and refs

* chore: add missing d.ts files for public API

* chore: adress code review FB

* chore: update api-report

* chore: dev-workflow for other apps

* chore: api update

* chore: update api-report
This commit is contained in:
Alexander Vakrilov
2019-10-17 00:45:33 +03:00
committed by GitHub
parent 6c7139477e
commit cc97a16800
880 changed files with 9090 additions and 2104 deletions

View File

@@ -0,0 +1,63 @@
Dialogs module. Examples:
```js
require("globals");
var dialogs = require("ui/dialogs");
dialogs.alert("Some message")
.then(function () { dialogs.alert("Alert closed!"); });
dialogs.alert("Some message", { title: "My custom title", okButtonText: "Close" })
.then(function () { dialogs.alert("Alert closed!"); });
dialogs.confirm("Some question?").then(function (r) { dialogs.alert("Result: " + r); });
dialogs.confirm("Some question?", { title: "My custom title", okButtonText: "Yes", cancelButtonText: "No" })
.then(function (r) { dialogs.alert("Result: " + r); });
dialogs.confirm("Some question?", { title: "My custom title", okButtonText: "Yes", cancelButtonText: "No", neutralButtonText: "Not sure" })
.then(function (r) { dialogs.alert("Result: " + r); });
dialogs.prompt("Some message")
.then(function (r) { dialogs.alert("Boolean result: " + r.result + ", entered text: " + r.text); }).fail(function (e) { console.log(e) });
dialogs.prompt("Some message", "Default text for the input", {
title: "My custom title", okButtonText: "Yes",
cancelButtonText: "No", neutralButtonText: "Not sure", inputType: dialogs.InputType.Password
}).then(function (r) { dialogs.alert("Boolean result: " + r.result + ", entered text: " + r.text); });
dialogs.login("Enter your user name and password:").then(function(r) {
dialogs.alert("Result:" + r.result + " User name:" + r.userName + " Password:" + r.password);
});
dialogs.login("Enter your user name and password:", "", "",
{
title: "Login",
okButtonText: "Sign In",
cancelButtonText: "Cancel",
neutralButtonText:"Sign Up"
})
.then(function(r) {
dialogs.alert("Result:" + r.result + " User name:" + r.userName + " Password:" + r.password);
if(r.result) {
// login here
} else if(r.result === false) {
// perform something on cancel if you want
} else if(r.result === "undefined") {
// you can create new user credentials here for example
}
}).fail(function(e){ console.log(e)});
```
Custom dialogs:
```js
require("globals");
var dialogs = require("ui/dialogs");
/// Splash
var d = new dialogs.Dialog("Loading...");
d.show();
setTimeout(function(){ d.hide(); }, 2000);
//or cancelable loading dialog
var d = new dialogs.Dialog("Loading...",
function(r){ dialogs.alert("You just canceled loading!"); }, { cancelButtonText: "Cancel" });
d.show();
setTimeout(function(){ d.hide(); }, 10000);
```

View File

@@ -0,0 +1,195 @@
// Types.
import { View } from "../core/view";
import { Color } from "../../color";
import { Page } from "../page";
import { isIOS } from "../../platform";
import { Frame as FrameDef } from "../frame";
import { LoginOptions } from "./dialogs";
import { isObject, isString } from "../../utils/types";
export const STRING = "string";
export const PROMPT = "Prompt";
export const CONFIRM = "Confirm";
export const ALERT = "Alert";
export const LOGIN = "Login";
export const OK = "OK";
export const CANCEL = "Cancel";
/**
* Defines the input type for prompt dialog.
*/
export module inputType {
/**
* Plain text input type.
*/
export const text: string = "text";
/**
* Password input type.
*/
export const password: string = "password";
/**
* Email input type.
*/
export const email: string = "email";
/**
* Number input type
*/
export const number: string = "number";
/**
* Decimal input type
*/
export const decimal: string = "decimal";
/**
* Phone input type
*/
export const phone: string = "phone";
}
/**
* Defines the capitalization type for prompt dialog.
*/
export module capitalizationType {
/**
* No automatic capitalization.
*/
export const none: string = "none";
/**
* Capitalizes every character.
*/
export const all: string = "all";
/**
* Capitalize the first word of each sentence.
*/
export const sentences: string = "sentences";
/**
* Capitalize the first letter of every word.
*/
export const words: string = "words";
}
let Frame: typeof FrameDef;
export function getCurrentPage(): Page {
if (!Frame) {
Frame = require("../frame").Frame;
}
let topmostFrame = Frame.topmost();
if (topmostFrame) {
return topmostFrame.currentPage;
}
return undefined;
}
function applySelectors<T extends View>(view: T, callback: (view: T) => void) {
let currentPage = getCurrentPage();
if (currentPage) {
let styleScope = currentPage._styleScope;
if (styleScope) {
view._inheritStyleScope(styleScope);
view.onLoaded();
callback(view);
view.onUnloaded();
}
}
}
let button: View;
let label: View;
let textField: View;
export function getButtonColors(): { color: Color, backgroundColor: Color } {
if (!button) {
const Button = require("../button").Button;
button = new Button;
if (isIOS) {
button._setupUI({});
}
}
let buttonColor: Color;
let buttonBackgroundColor: Color;
applySelectors(button, (btn) => {
buttonColor = btn.color;
buttonBackgroundColor = <Color>btn.backgroundColor;
});
return { color: buttonColor, backgroundColor: buttonBackgroundColor };
}
export function getLabelColor(): Color {
if (!label) {
const Label = require("../label").Label;
label = new Label;
if (isIOS) {
label._setupUI({});
}
}
let labelColor: Color;
applySelectors(label, (lbl) => {
labelColor = lbl.color;
});
return labelColor;
}
export function getTextFieldColor(): Color {
if (!textField) {
const TextField = require("../text-field").TextField;
textField = new TextField();
if (isIOS) {
textField._setupUI({});
}
}
let textFieldColor: Color;
applySelectors(textField, (tf) => {
textFieldColor = tf.color;
});
return textFieldColor;
}
export function isDialogOptions(arg): boolean {
return arg && (arg.message || arg.title);
}
export function parseLoginOptions(args: any[]): LoginOptions {
// Handle options object first
if (args.length === 1 && isObject(args[0])) {
return args[0];
}
let options: LoginOptions = { title: LOGIN, okButtonText: OK, cancelButtonText: CANCEL };
if (isString(args[0])) {
options.message = args[0];
}
if (isString(args[1])) {
options.userNameHint = args[1];
}
if (isString(args[2])) {
options.passwordHint = args[2];
}
if (isString(args[3])) {
options.userName = args[3];
}
if (isString(args[4])) {
options.password = args[4];
}
return options;
}

View File

@@ -0,0 +1,352 @@
/**
* Android specific dialogs functions implementation.
*/
import { DialogOptions, ConfirmOptions, PromptOptions, PromptResult, LoginOptions, LoginResult, ActionOptions } from ".";
import { getLabelColor, getButtonColors, isDialogOptions, inputType, capitalizationType, ALERT, OK, CONFIRM, CANCEL, PROMPT, parseLoginOptions } from "./dialogs-common";
import { android as androidApp } from "../../application";
export * from "./dialogs-common";
function isString(value): value is string {
return typeof value === "string";
}
function createAlertDialog(options?: DialogOptions): android.app.AlertDialog.Builder {
const alert = new android.app.AlertDialog.Builder(androidApp.foregroundActivity);
alert.setTitle(options && isString(options.title) ? options.title : "");
alert.setMessage(options && isString(options.message) ? options.message : "");
if (options && options.cancelable === false) {
alert.setCancelable(false);
}
return alert;
}
function showDialog(builder: android.app.AlertDialog.Builder) {
const dlg = builder.show();
const labelColor = getLabelColor();
if (labelColor) {
const textViewId = dlg.getContext().getResources().getIdentifier("android:id/alertTitle", null, null);
if (textViewId) {
const tv = <android.widget.TextView>dlg.findViewById(textViewId);
if (tv) {
tv.setTextColor(labelColor.android);
}
}
const messageTextViewId = dlg.getContext().getResources().getIdentifier("android:id/message", null, null);
if (messageTextViewId) {
const messageTextView = <android.widget.TextView>dlg.findViewById(messageTextViewId);
if (messageTextView) {
messageTextView.setTextColor(labelColor.android);
}
}
}
let { color, backgroundColor } = getButtonColors();
if (color) {
let buttons: android.widget.Button[] = [];
for (let i = 0; i < 3; i++) {
let id = dlg.getContext().getResources().getIdentifier("android:id/button" + i, null, null);
buttons[i] = <android.widget.Button>dlg.findViewById(id);
}
buttons.forEach(button => {
if (button) {
if (color) {
button.setTextColor(color.android);
}
if (backgroundColor) {
button.setBackgroundColor(backgroundColor.android);
}
}
});
}
}
function addButtonsToAlertDialog(alert: android.app.AlertDialog.Builder, options: ConfirmOptions,
callback: Function): void {
if (!options) {
return;
}
if (options.okButtonText) {
alert.setPositiveButton(options.okButtonText, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, id: number) {
dialog.cancel();
callback(true);
}
}));
}
if (options.cancelButtonText) {
alert.setNegativeButton(options.cancelButtonText, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, id: number) {
dialog.cancel();
callback(false);
}
}));
}
if (options.neutralButtonText) {
alert.setNeutralButton(options.neutralButtonText, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, id: number) {
dialog.cancel();
callback(undefined);
}
}));
}
alert.setOnDismissListener(new android.content.DialogInterface.OnDismissListener({
onDismiss: function () {
callback(false);
}
}));
}
export function alert(arg: any): Promise<void> {
return new Promise<void>((resolve, reject) => {
try {
const options = !isDialogOptions(arg) ? { title: ALERT, okButtonText: OK, message: arg + "" } : arg;
const alert = createAlertDialog(options);
alert.setPositiveButton(options.okButtonText, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, id: number) {
dialog.cancel();
resolve();
}
}));
alert.setOnDismissListener(new android.content.DialogInterface.OnDismissListener({
onDismiss: function () {
resolve();
}
}));
showDialog(alert);
} catch (ex) {
reject(ex);
}
});
}
export function confirm(arg: any): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
try {
const options = !isDialogOptions(arg) ? { title: CONFIRM, okButtonText: OK, cancelButtonText: CANCEL, message: arg + "" } : arg;
const alert = createAlertDialog(options);
addButtonsToAlertDialog(alert, options, function (result) { resolve(result); });
showDialog(alert);
} catch (ex) {
reject(ex);
}
});
}
export function prompt(arg: any): Promise<PromptResult> {
let options: PromptOptions;
const defaultOptions = {
title: PROMPT,
okButtonText: OK,
cancelButtonText: CANCEL,
inputType: inputType.text,
};
if (arguments.length === 1) {
if (isString(arg)) {
options = defaultOptions;
options.message = arg;
} else {
options = arg;
}
} else if (arguments.length === 2) {
if (isString(arguments[0]) && isString(arguments[1])) {
options = defaultOptions;
options.message = arguments[0];
options.defaultText = arguments[1];
}
}
return new Promise<PromptResult>((resolve, reject) => {
try {
const alert = createAlertDialog(options);
const input = new android.widget.EditText(androidApp.foregroundActivity);
if (options) {
if (options.inputType === inputType.password) {
input.setInputType(android.text.InputType.TYPE_CLASS_TEXT | android.text.InputType.TYPE_TEXT_VARIATION_PASSWORD);
} else if (options.inputType === inputType.email) {
input.setInputType(android.text.InputType.TYPE_CLASS_TEXT | android.text.InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS);
} else if (options.inputType === inputType.number) {
input.setInputType(android.text.InputType.TYPE_CLASS_NUMBER);
} else if (options.inputType === inputType.decimal) {
input.setInputType(android.text.InputType.TYPE_CLASS_NUMBER | android.text.InputType.TYPE_NUMBER_FLAG_DECIMAL);
} else if (options.inputType === inputType.phone) {
input.setInputType(android.text.InputType.TYPE_CLASS_PHONE);
}
switch (options.capitalizationType) {
case capitalizationType.all: {
input.setInputType(input.getInputType() | android.text.InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS);
break;
}
case capitalizationType.sentences: {
input.setInputType(input.getInputType() | android.text.InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
break;
}
case capitalizationType.words: {
input.setInputType(input.getInputType() | android.text.InputType.TYPE_TEXT_FLAG_CAP_WORDS);
break;
}
}
}
input.setText(options && options.defaultText || "");
alert.setView(input);
const getText = function () { return input.getText().toString(); };
addButtonsToAlertDialog(alert, options, function (r) { resolve({ result: r, text: getText() }); });
showDialog(alert);
} catch (ex) {
reject(ex);
}
});
}
export function login(...args: any[]): Promise<LoginResult> {
let options: LoginOptions = parseLoginOptions(args);
return new Promise<LoginResult>((resolve, reject) => {
try {
const context = androidApp.foregroundActivity;
const alert = createAlertDialog(options);
const userNameInput = new android.widget.EditText(context);
userNameInput.setHint(options.userNameHint ? options.userNameHint : "");
userNameInput.setText(options.userName ? options.userName : "");
const passwordInput = new android.widget.EditText(context);
passwordInput.setInputType(android.text.InputType.TYPE_CLASS_TEXT | android.text.InputType.TYPE_TEXT_VARIATION_PASSWORD);
passwordInput.setTypeface(android.graphics.Typeface.DEFAULT);
passwordInput.setHint(options.passwordHint ? options.passwordHint : "");
passwordInput.setText(options.password ? options.password : "");
const layout = new android.widget.LinearLayout(context);
layout.setOrientation(1);
layout.addView(userNameInput);
layout.addView(passwordInput);
alert.setView(layout);
addButtonsToAlertDialog(alert, options, function (r) {
resolve({
result: r,
userName: userNameInput.getText().toString(),
password: passwordInput.getText().toString()
});
});
showDialog(alert);
} catch (ex) {
reject(ex);
}
});
}
export function action(arg: any): Promise<string> {
let options: ActionOptions;
const defaultOptions = { title: null, cancelButtonText: CANCEL };
if (arguments.length === 1) {
if (isString(arguments[0])) {
options = defaultOptions;
options.message = arguments[0];
} else {
options = arguments[0];
}
} else if (arguments.length === 2) {
if (isString(arguments[0]) && isString(arguments[1])) {
options = defaultOptions;
options.message = arguments[0];
options.cancelButtonText = arguments[1];
}
} else if (arguments.length === 3) {
if (isString(arguments[0]) && isString(arguments[1]) && typeof arguments[2] !== "undefined") {
options = defaultOptions;
options.message = arguments[0];
options.cancelButtonText = arguments[1];
options.actions = arguments[2];
}
}
return new Promise<string>((resolve, reject) => {
try {
const activity = androidApp.foregroundActivity || androidApp.startActivity;
const alert = new android.app.AlertDialog.Builder(activity);
const message = options && isString(options.message) ? options.message : "";
const title = options && isString(options.title) ? options.title : "";
if (options && options.cancelable === false) {
alert.setCancelable(false);
}
if (title) {
alert.setTitle(title);
if (!options.actions) {
alert.setMessage(message);
}
}
else {
alert.setTitle(message);
}
if (options.actions) {
alert.setItems(options.actions, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, which: number) {
resolve(options.actions[which]);
}
}));
}
if (isString(options.cancelButtonText)) {
alert.setNegativeButton(options.cancelButtonText, new android.content.DialogInterface.OnClickListener({
onClick: function (dialog: android.content.DialogInterface, id: number) {
dialog.cancel();
resolve(options.cancelButtonText);
}
}));
}
alert.setOnDismissListener(new android.content.DialogInterface.OnDismissListener({
onDismiss: function () {
if (isString(options.cancelButtonText)) {
resolve(options.cancelButtonText);
} else {
resolve("");
}
}
}));
showDialog(alert);
} catch (ex) {
reject(ex);
}
});
}

View File

@@ -0,0 +1,295 @@
/**
* Allows you to show different dialogs such as alerts, prompts, etc.
* @module "ui/dialogs"
*/ /** */
/**
* Defines the input type for prompt dialog.
*/
export module inputType {
/**
* Plain text input type.
*/
export const text: string;
/**
* Password input type.
*/
export const password: string;
/**
* Email input type.
*/
export const email: string;
/**
* Number input type.
*/
export const number: string;
/**
* Decimal input type.
*/
export const decimal: string;
/**
* Phone input type.
*/
export const phone: string;
}
/**
* Defines the capitalization type for prompt dialog.
*/
export module capitalizationType {
/**
* No automatic capitalization.
*/
export const none: string;
/**
* Capitalizes every character.
*/
export const all: string;
/**
* Capitalize the first word of each sentence.
*/
export const sentences: string;
/**
* Capitalize the first letter of every word.
*/
export const words: string;
}
/**
* The alert() method displays an alert box with a specified message.
* @param message Specifies the text to display in the alert box.
*/
export function alert(message: string | number | boolean): Promise<void>;
/**
* The alert() method displays an alert box with a specified message.
* @param options Specifies the options for the alert box.
*/
export function alert(options: AlertOptions): Promise<void>;
/**
* The confirm() method displays a dialog box with a specified message.
* @param message Specifies the text to display in the confirm box.
*/
export function confirm(message: string): Promise<boolean>;
/**
* The confirm() method displays a dialog box with a specified message.
* @param options Specifies the options for the confirm box.
*/
export function confirm(options: ConfirmOptions): Promise<boolean>;
/**
* The prompt() method displays a dialog box that prompts the visitor for input.
* @param message The text to display in the dialog box.
* @param defaultText The default text to display in the input box. Optional.
*/
export function prompt(message: string, defaultText?: string): Promise<PromptResult>;
/**
* The prompt() method displays a dialog box that prompts the visitor for input.
* @param options The options for the dialog box.
*/
export function prompt(options: PromptOptions): Promise<PromptResult>;
/**
* The login() method displays a login dialog box that prompts the visitor for user name and password.
* @param message The text to display in the dialog box.
* @param userNameHint The default text to display as a hint in the username input. Optional.
* @param passwordHint The default text to display as a hint in the password input. Optional.
* @param userName The default text to display in the user name input box. Optional.
* @param password The default text to display in the password input box. Optional.
*/
export function login(message: string, userNameHint?: string, passwordHint?: string, userName?: string, password?: string): Promise<LoginResult>;
/**
* The login() method displays a login dialog box that prompts the visitor for user name and password.
* @param message The text to display in the dialog box.
* @param userNameHint The default text to display as a hint in the username input. Optional.
* @param passwordHint The default text to display as a hint in the password input. Optional.
*/
export function login(message: string, userNameHint?: string, passwordHint?: string): Promise<LoginResult>;
/**
* The login() method displays a login dialog box that prompts the visitor for user name and password.
* @param options The options for the dialog box.
*/
export function login(options: LoginOptions): Promise<LoginResult>;
/**
* The action() method displays a action box that prompts the visitor to choose some action.
* @param message The text to display in the dialog box.
* @param cancelButtonText The text to display in the cancel button.
* @param actions List of available actions.
*/
export function action(message: string, cancelButtonText: string, actions: Array<string>): Promise<string>;
/**
* The action() method displays a action box that prompts the visitor to choose some action.
* @param options The options for the dialog box.
*/
export function action(options: ActionOptions): Promise<string>;
/**
* Provides options for the dialog.
*/
export interface CancelableOptions {
/**
* [Android only] Gets or sets if the dialog can be canceled by taping outside of the dialog.
*/
cancelable?: boolean;
}
/**
* Provides options for the dialog.
*/
export interface ActionOptions extends CancelableOptions {
/**
* Gets or sets the dialog title.
*/
title?: string;
/**
* Gets or sets the dialog message.
*/
message?: string;
/**
* Gets or sets the Cancel button text.
*/
cancelButtonText?: string;
/**
* Gets or sets the list of available actions.
*/
actions?: Array<string>;
}
/**
* Provides options for the dialog.
*/
export interface DialogOptions extends CancelableOptions {
/**
* Gets or sets the dialog title.
*/
title?: string;
/**
* Gets or sets the dialog message.
*/
message?: string;
}
/**
* Provides options for the alert.
*/
export interface AlertOptions extends DialogOptions {
/**
* Gets or sets the OK button text.
*/
okButtonText?: string;
}
/**
* Provides options for the confirm dialog.
*/
export interface ConfirmOptions extends AlertOptions {
/**
* Gets or sets the Cancel button text.
*/
cancelButtonText?: string;
/**
* Gets or sets the neutral button text.
*/
neutralButtonText?: string;
}
/**
* Provides options for the prompt dialog.
*/
export interface PromptOptions extends ConfirmOptions {
/**
* Gets or sets the default text to display in the input box.
*/
defaultText?: string;
/**
* Gets or sets the prompt input type (plain text, password, or email).
*/
inputType?: string;
/**
* Gets or sets the prompt capitalizationType (none, all, sentences, or words).
*/
capitalizationType?: string;
}
/**
* Provides options for the login dialog.
*/
export interface LoginOptions extends ConfirmOptions {
/**
* Gets or sets the default text to display as hint in the user name input box.
*/
userNameHint?: string;
/**
* Gets or sets the default text to display as hint in the password input box.
*/
passwordHint?: string;
/**
* Gets or sets the default text to display in the user name input box.
*/
userName?: string;
/**
* Gets or sets the default text to display in the password input box.
*/
password?: string;
}
/**
* Provides result data from the prompt dialog.
*/
export interface PromptResult {
/**
* Gets or sets the prompt dialog boolean result.
*/
result: boolean;
/**
* Gets or sets the text entered in the prompt dialog.
*/
text: string;
}
/**
* Provides result data from the login dialog.
*/
export interface LoginResult {
/**
* Gets or sets the login dialog boolean result.
*/
result: boolean;
/**
* Gets or sets the user entered in the login dialog.
*/
userName: string;
/**
* Gets or sets the password entered in the login dialog.
*/
password: string;
}

View File

@@ -0,0 +1,304 @@
/**
* iOS specific dialogs functions implementation.
*/
import { ios as iosView } from "../core/view";
import { ConfirmOptions, PromptOptions, PromptResult, LoginOptions, LoginResult, ActionOptions } from ".";
import { getCurrentPage, getLabelColor, getButtonColors, getTextFieldColor, isDialogOptions, inputType, capitalizationType, ALERT, OK, CONFIRM, CANCEL, PROMPT, parseLoginOptions } from "./dialogs-common";
import { isString, isDefined, isFunction } from "../../utils/types";
import { getRootView } from "../../application";
export * from "./dialogs-common";
function addButtonsToAlertController(alertController: UIAlertController, options: ConfirmOptions, callback?: Function): void {
if (!options) {
return;
}
if (isString(options.cancelButtonText)) {
alertController.addAction(UIAlertAction.actionWithTitleStyleHandler(options.cancelButtonText, UIAlertActionStyle.Default, () => {
raiseCallback(callback, false);
}));
}
if (isString(options.neutralButtonText)) {
alertController.addAction(UIAlertAction.actionWithTitleStyleHandler(options.neutralButtonText, UIAlertActionStyle.Default, () => {
raiseCallback(callback, undefined);
}));
}
if (isString(options.okButtonText)) {
alertController.addAction(UIAlertAction.actionWithTitleStyleHandler(options.okButtonText, UIAlertActionStyle.Default, () => {
raiseCallback(callback, true);
}));
}
}
function raiseCallback(callback, result) {
if (isFunction(callback)) {
callback(result);
}
}
export function alert(arg: any): Promise<void> {
return new Promise<void>((resolve, reject) => {
try {
let options = !isDialogOptions(arg) ? { title: ALERT, okButtonText: OK, message: arg + "" } : arg;
let alertController = UIAlertController.alertControllerWithTitleMessagePreferredStyle(options.title, options.message, UIAlertControllerStyle.Alert);
addButtonsToAlertController(alertController, options, () => { resolve(); });
showUIAlertController(alertController);
} catch (ex) {
reject(ex);
}
});
}
export function confirm(arg: any): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
try {
let options = !isDialogOptions(arg) ? { title: CONFIRM, okButtonText: OK, cancelButtonText: CANCEL, message: arg + "" } : arg;
let alertController = UIAlertController.alertControllerWithTitleMessagePreferredStyle(options.title, options.message, UIAlertControllerStyle.Alert);
addButtonsToAlertController(alertController, options, (r) => { resolve(r); });
showUIAlertController(alertController);
} catch (ex) {
reject(ex);
}
});
}
export function prompt(arg: any): Promise<PromptResult> {
let options: PromptOptions;
let defaultOptions = {
title: PROMPT,
okButtonText: OK,
cancelButtonText: CANCEL,
inputType: inputType.text,
};
if (arguments.length === 1) {
if (isString(arg)) {
options = defaultOptions;
options.message = arg;
} else {
options = arg;
}
} else if (arguments.length === 2) {
if (isString(arguments[0]) && isString(arguments[1])) {
options = defaultOptions;
options.message = arguments[0];
options.defaultText = arguments[1];
}
}
return new Promise<PromptResult>((resolve, reject) => {
try {
let textField: UITextField;
let alertController = UIAlertController.alertControllerWithTitleMessagePreferredStyle(options.title, options.message, UIAlertControllerStyle.Alert);
alertController.addTextFieldWithConfigurationHandler((arg: UITextField) => {
arg.text = isString(options.defaultText) ? options.defaultText : "";
arg.secureTextEntry = options && options.inputType === inputType.password;
if (options && options.inputType === inputType.email) {
arg.keyboardType = UIKeyboardType.EmailAddress;
} else if (options && options.inputType === inputType.number) {
arg.keyboardType = UIKeyboardType.NumberPad;
} else if (options && options.inputType === inputType.decimal) {
arg.keyboardType = UIKeyboardType.DecimalPad;
} else if (options && options.inputType === inputType.phone) {
arg.keyboardType = UIKeyboardType.PhonePad;
}
let color = getTextFieldColor();
if (color) {
arg.textColor = arg.tintColor = color.ios;
}
});
textField = alertController.textFields.firstObject;
if (options) {
switch (options.capitalizationType) {
case capitalizationType.all: {
textField.autocapitalizationType = UITextAutocapitalizationType.AllCharacters; break;
}
case capitalizationType.sentences: {
textField.autocapitalizationType = UITextAutocapitalizationType.Sentences; break;
}
case capitalizationType.words: {
textField.autocapitalizationType = UITextAutocapitalizationType.Words; break;
}
default: {
textField.autocapitalizationType = UITextAutocapitalizationType.None;
}
}
}
addButtonsToAlertController(alertController, options,
(r) => { resolve({ result: r, text: textField.text }); });
showUIAlertController(alertController);
} catch (ex) {
reject(ex);
}
});
}
export function login(...args: any[]): Promise<LoginResult> {
let options: LoginOptions = parseLoginOptions(args);
return new Promise<LoginResult>((resolve, reject) => {
try {
let userNameTextField: UITextField;
let passwordTextField: UITextField;
let alertController = UIAlertController.alertControllerWithTitleMessagePreferredStyle(options.title, options.message, UIAlertControllerStyle.Alert);
let textFieldColor = getTextFieldColor();
alertController.addTextFieldWithConfigurationHandler((arg: UITextField) => {
arg.placeholder = "Login";
arg.placeholder = options.userNameHint ? options.userNameHint : "";
arg.text = isString(options.userName) ? options.userName : "";
if (textFieldColor) {
arg.textColor = arg.tintColor = textFieldColor.ios;
}
});
alertController.addTextFieldWithConfigurationHandler((arg: UITextField) => {
arg.placeholder = "Password";
arg.secureTextEntry = true;
arg.placeholder = options.passwordHint ? options.passwordHint : "";
arg.text = isString(options.password) ? options.password : "";
if (textFieldColor) {
arg.textColor = arg.tintColor = textFieldColor.ios;
}
});
userNameTextField = alertController.textFields.firstObject;
passwordTextField = alertController.textFields.lastObject;
addButtonsToAlertController(alertController, options,
(r) => {
resolve({
result: r,
userName:
userNameTextField.text,
password: passwordTextField.text
});
});
showUIAlertController(alertController);
} catch (ex) {
reject(ex);
}
});
}
function showUIAlertController(alertController: UIAlertController) {
let currentView = getCurrentPage() || getRootView();
if (currentView) {
currentView = currentView.modal || currentView;
let viewController: UIViewController = currentView.ios;
if (viewController.presentedViewController) {
viewController = viewController.presentedViewController;
}
if (!(currentView.ios instanceof UIViewController)) {
const parentWithController = iosView.getParentWithViewController(currentView);
viewController = parentWithController ? parentWithController.viewController : undefined;
}
if (viewController) {
if (alertController.popoverPresentationController) {
alertController.popoverPresentationController.sourceView = viewController.view;
alertController.popoverPresentationController.sourceRect = CGRectMake(viewController.view.bounds.size.width / 2.0, viewController.view.bounds.size.height / 2.0, 1.0, 1.0);
alertController.popoverPresentationController.permittedArrowDirections = 0;
}
let color = getButtonColors().color;
if (color) {
alertController.view.tintColor = color.ios;
}
let lblColor = getLabelColor();
if (lblColor) {
if (alertController.title) {
let title = NSAttributedString.alloc().initWithStringAttributes(alertController.title, <any>{ [NSForegroundColorAttributeName]: lblColor.ios });
alertController.setValueForKey(title, "attributedTitle");
}
if (alertController.message) {
let message = NSAttributedString.alloc().initWithStringAttributes(alertController.message, <any>{ [NSForegroundColorAttributeName]: lblColor.ios });
alertController.setValueForKey(message, "attributedMessage");
}
}
viewController.presentModalViewControllerAnimated(alertController, true);
}
}
}
export function action(): Promise<string> {
let options: ActionOptions;
let defaultOptions = { title: null, cancelButtonText: CANCEL };
if (arguments.length === 1) {
if (isString(arguments[0])) {
options = defaultOptions;
options.message = arguments[0];
} else {
options = arguments[0];
}
} else if (arguments.length === 2) {
if (isString(arguments[0]) && isString(arguments[1])) {
options = defaultOptions;
options.message = arguments[0];
options.cancelButtonText = arguments[1];
}
} else if (arguments.length === 3) {
if (isString(arguments[0]) && isString(arguments[1]) && isDefined(arguments[2])) {
options = defaultOptions;
options.message = arguments[0];
options.cancelButtonText = arguments[1];
options.actions = arguments[2];
}
}
return new Promise<string>((resolve, reject) => {
try {
let i: number;
let action: string;
let alertController = UIAlertController.alertControllerWithTitleMessagePreferredStyle(options.title, options.message, UIAlertControllerStyle.ActionSheet);
if (options.actions) {
for (i = 0; i < options.actions.length; i++) {
action = options.actions[i];
if (isString(action)) {
alertController.addAction(UIAlertAction.actionWithTitleStyleHandler(action, UIAlertActionStyle.Default, (arg: UIAlertAction) => {
resolve(arg.title);
}));
}
}
}
if (isString(options.cancelButtonText)) {
alertController.addAction(UIAlertAction.actionWithTitleStyleHandler(options.cancelButtonText, UIAlertActionStyle.Cancel, (arg: UIAlertAction) => {
resolve(arg.title);
}));
}
showUIAlertController(alertController);
} catch (ex) {
reject(ex);
}
});
}

View File

@@ -0,0 +1,5 @@
{
"name": "dialogs",
"main": "dialogs",
"types": "dialogs.d.ts"
}