@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

package/example/node_modules/expo-modules-autolinking/build/reactNativeConfig/reactNativeConfig.types.d.ts

@@ -0,0 +1,95 @@
+import type { SupportedPlatform } from '../types';
+/**
+ * Options for 'react-native-config' command.
+ */
+export interface RNConfigCommandOptions {
+    platform: SupportedPlatform;
+    projectRoot: string;
+    searchPaths: string[];
+    transitiveLinkingDependencies: string[];
+}
+/**
+ * Dependency configuration for Android platform.
+ */
+export interface RNConfigDependencyAndroid {
+    sourceDir: string;
+    packageImportPath: string;
+    packageInstance: string;
+    dependencyConfiguration?: string;
+    buildTypes: string[];
+    libraryName?: string | null;
+    componentDescriptors?: string[] | null;
+    cmakeListsPath?: string | null;
+    cxxModuleCMakeListsModuleName?: string | null;
+    cxxModuleCMakeListsPath?: string | null;
+    cxxModuleHeaderName?: string | null;
+}
+/**
+ * Dependency configuration for iOS platform.
+ */
+export interface RNConfigDependencyIos {
+    podspecPath: string;
+    version: string;
+    configurations: string[];
+    scriptPhases: any[];
+}
+/**
+ * Dependency configuration.
+ */
+export interface RNConfigDependency {
+    root: string;
+    name: string;
+    platforms: {
+        android?: RNConfigDependencyAndroid;
+        ios?: RNConfigDependencyIos;
+    };
+}
+/**
+ * Result of 'react-native-config' command.
+ */
+export interface RNConfigResult {
+    root: string;
+    reactNativePath: string;
+    dependencies: Record<string, RNConfigDependency>;
+    project: {
+        ios?: {
+            sourceDir: string;
+        };
+    };
+}
+export type RNConfigReactNativePlatformsConfigAndroid = any;
+export type RNConfigReactNativePlatformsConfigIos = any;
+interface RNConfigReactNativePlatformsConfig {
+    root?: string;
+    platforms?: {
+        android?: RNConfigReactNativePlatformsConfigAndroid;
+        ios?: RNConfigReactNativePlatformsConfigIos;
+    };
+}
+/**
+ * The `react-native.config.js` config from projectRoot.
+ */
+export interface RNConfigReactNativeProjectConfig {
+    dependencies?: Record<string, RNConfigReactNativePlatformsConfig>;
+}
+/**
+ * The `react-native.config.js` config from library packageRoot.
+ */
+export interface RNConfigReactNativeLibraryConfig {
+    dependency?: RNConfigReactNativePlatformsConfig;
+    platforms?: any;
+}
+export type RNConfigReactNativeConfig = RNConfigReactNativeProjectConfig | RNConfigReactNativeLibraryConfig;
+/**
+ * The `project` config represents the app project configuration.
+ */
+export interface RNConfigReactNativeAppProjectConfig {
+    android?: {
+        sourceDir: string;
+        packageName: string;
+    };
+    ios?: {
+        sourceDir: string;
+    };
+}
+export {};

package/example/node_modules/expo-modules-autolinking/build/types.d.ts

@@ -0,0 +1,319 @@
+import { ExpoModuleConfig } from './ExpoModuleConfig';
+type Required<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type WithRequired<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Required<T, K>;
+export type SupportedPlatform = 'apple' | 'ios' | 'android' | 'web' | 'macos' | 'tvos' | 'devtools';
+/**
+ * Options that can be passed through `expo.autolinking` config in the package.json file.
+ */
+export type AutolinkingOptions = {
+    searchPaths?: string[] | null;
+    ignorePaths?: string[] | null;
+    exclude?: string[] | null;
+    flags?: Record<string, any>;
+};
+export type AndroidAutolinkingOptions = AutolinkingOptions & {
+    buildFromSource?: string[] | null;
+};
+export type BaseAutolinkingOptions = AutolinkingOptions & {
+    [key in SupportedPlatform]?: AutolinkingOptions;
+};
+export interface PlatformAutolinkingOptions extends BaseAutolinkingOptions {
+    android?: AndroidAutolinkingOptions;
+}
+export interface SearchOptions {
+    searchPaths: string[];
+    ignorePaths?: string[] | null;
+    exclude?: string[] | null;
+    platform: SupportedPlatform;
+    silent?: boolean;
+    nativeModulesDir?: string | null;
+    projectRoot: string;
+    /**
+     * Filter the search results to only include the project dependencies.
+     * In a monorepo, you may like to set this to false and link all modules from the monorepo.
+     * @default true
+     */
+    onlyProjectDeps?: boolean;
+    flags?: Record<string, any>;
+    android?: {
+        buildFromSource?: string[] | null;
+    };
+}
+export interface ResolveOptions extends SearchOptions {
+    json?: boolean;
+}
+export interface GenerateOptions extends ResolveOptions {
+    target: string;
+    namespace?: string;
+    empty?: boolean;
+}
+export interface GenerateModulesProviderOptions extends ResolveOptions {
+    target: string;
+    entitlement?: string;
+    packages: string[];
+}
+export type PackageRevision = {
+    path: string;
+    version: string;
+    config?: ExpoModuleConfig;
+    duplicates?: PackageRevision[];
+};
+export type SearchResults = {
+    [moduleName: string]: PackageRevision;
+};
+export interface ModuleAndroidProjectInfo {
+    name: string;
+    sourceDir: string;
+    modules: string[];
+    publication?: AndroidPublication;
+    aarProjects?: AndroidGradleAarProjectDescriptor[];
+    shouldUsePublicationScriptPath?: string;
+}
+export interface ModuleAndroidPluginInfo {
+    id: string;
+    sourceDir: string;
+}
+export interface ModuleAndroidAarProjectInfo extends AndroidGradleAarProjectDescriptor {
+    projectDir: string;
+}
+export interface CommonNativeModuleDescriptor {
+    packageName: string;
+    coreFeatures?: string[];
+}
+export interface ModuleDescriptorAndroid extends CommonNativeModuleDescriptor {
+    projects?: ModuleAndroidProjectInfo[];
+    plugins?: ModuleAndroidPluginInfo[];
+}
+export interface ModuleIosPodspecInfo {
+    podName: string;
+    podspecDir: string;
+}
+export interface ModuleDescriptorIos extends CommonNativeModuleDescriptor {
+    modules: string[];
+    pods: ModuleIosPodspecInfo[];
+    flags: Record<string, any> | undefined;
+    swiftModuleNames: string[];
+    appDelegateSubscribers: string[];
+    reactDelegateHandlers: string[];
+    debugOnly: boolean;
+}
+export interface ModuleDescriptorDevTools {
+    packageName: string;
+    packageRoot: string;
+    webpageRoot: string;
+}
+export type ModuleDescriptor = ModuleDescriptorAndroid | ModuleDescriptorIos | ModuleDescriptorDevTools;
+export interface AndroidGradlePluginDescriptor {
+    /**
+     * Gradle plugin ID
+     */
+    id: string;
+    /**
+     * Artifact group
+     */
+    group: string;
+    /**
+     * Relative path to the gradle plugin directory
+     */
+    sourceDir: string;
+    /**
+     * Whether to apply the plugin to the root project
+     * Defaults to true
+     */
+    applyToRootProject?: boolean;
+}
+export interface AndroidGradleAarProjectDescriptor {
+    /**
+     * Gradle project name
+     */
+    name: string;
+    /**
+     * Path to the AAR file
+     */
+    aarFilePath: string;
+}
+/**
+ * Information about the available publication of an Android AAR file.
+ */
+export interface AndroidPublication {
+    /**
+     * The Maven artifact ID.
+     */
+    id: string;
+    /**
+     * The Maven group ID.
+     */
+    group: string;
+    /**
+     * The Maven version.
+     */
+    version: string;
+    /**
+     * The Maven repository.
+     */
+    repository: string;
+}
+/**
+ * Represents a raw config specific to Apple platforms.
+ */
+export type RawModuleConfigApple = {
+    /**
+     * Names of Swift native modules classes to put to the generated modules provider file.
+     */
+    modules?: string[];
+    /**
+     * Names of Swift classes that hooks into `ExpoAppDelegate` to receive AppDelegate life-cycle events.
+     */
+    appDelegateSubscribers?: string[];
+    /**
+     * Names of Swift classes that implement `ExpoReactDelegateHandler` to hook React instance creation.
+     */
+    reactDelegateHandlers?: string[];
+    /**
+     * Podspec relative path.
+     * To have multiple podspecs, string array type is also supported.
+     */
+    podspecPath?: string | string[];
+    /**
+     * Swift product module name. If empty, the pod name is used for Swift imports.
+     * To have multiple modules, string array is also supported.
+     */
+    swiftModuleName?: string | string[];
+    /**
+     * Whether this module will be added only to the debug configuration.
+     * Defaults to false.
+     */
+    debugOnly?: boolean;
+};
+/**
+ * Represents a raw config specific to Android platforms.
+ */
+export type RawAndroidProjectConfig = {
+    /**
+     * The name of the project. It will be used as the Gradle project name.
+     */
+    name?: string;
+    /**
+     * The path to the project directory. Should contain the `build.gradle{.kts}` file.
+     * It's relative to the module root directory.
+     */
+    path?: string;
+    /**
+     * Information about the available publication of an Android AAR file
+     */
+    publication?: AndroidPublication;
+    /**
+     * The path to the script that determines whether the publication should be used.
+     * Evaluate in the context of the `settings.gradle` file.
+     * Won't be run if the publication is not defined.
+     */
+    shouldUsePublicationScriptPath?: string;
+    /**
+     * Names of the modules to be linked in the project.
+     */
+    modules?: string[];
+    /**
+     * Prebuilded AAR projects.
+     */
+    gradleAarProjects?: AndroidGradleAarProjectDescriptor[];
+};
+export type RawAndroidConfig = {
+    projects?: WithRequired<RawAndroidProjectConfig, 'name' | 'path'>[];
+    /**
+     * Gradle plugins.
+     */
+    gradlePlugins?: AndroidGradlePluginDescriptor[];
+} & RawAndroidProjectConfig;
+/**
+ * Represents a raw config from `expo-module.json`.
+ */
+export interface RawExpoModuleConfig {
+    /**
+     * An array of supported platforms.
+     */
+    platforms?: SupportedPlatform[];
+    /**
+     * A config for all Apple platforms.
+     */
+    apple?: RawModuleConfigApple;
+    /**
+     * The legacy config previously used for iOS platform. For backwards compatibility it's used as the fallback for `apple`.
+     * @deprecated As the module can now support more than iOS platform, use the generic `apple` config instead.
+     */
+    ios?: RawModuleConfigApple;
+    /**
+     * Android-specific config.
+     */
+    android?: RawAndroidConfig;
+    /**
+     * List of core features that this module requires.
+     */
+    coreFeatures?: string[];
+    /**
+     * DevTools-specific config.
+     */
+    devtools?: {
+        /**
+         * The webpage root directory for Expo CLI DevTools to serve the web resources.
+         */
+        webpageRoot: string;
+    };
+}
+interface AndroidMavenRepositoryPasswordCredentials {
+    username: string;
+    password: string;
+}
+interface AndroidMavenRepositoryHttpHeaderCredentials {
+    name: string;
+    value: string;
+}
+interface AndroidMavenRepositoryAWSCredentials {
+    accessKey: string;
+    secretKey: string;
+    sessionToken?: string;
+}
+type AndroidMavenRepositoryCredentials = AndroidMavenRepositoryPasswordCredentials | AndroidMavenRepositoryHttpHeaderCredentials | AndroidMavenRepositoryAWSCredentials;
+export interface AndroidMavenRepository {
+    /**
+     * The URL of the Maven repository.
+     */
+    url: string;
+    /**
+     * The credentials to use when accessing the Maven repository.
+     * May be of type PasswordCredentials, HttpHeaderCredentials, or AWSCredentials.
+     *
+     * @see the authentication schemes section of [Gradle documentation](https://docs.gradle.org/current/userguide/declaring_repositories.html#sec:authentication_schemes) for more information.
+     */
+    credentials?: AndroidMavenRepositoryCredentials;
+    /**
+     * The authentication scheme to use when accessing the Maven repository.
+     */
+    authentication?: 'basic' | 'digest' | 'header';
+}
+interface ApplePod {
+    name: string;
+    version?: string;
+    configurations?: string[];
+    modular_headers?: boolean;
+    source?: string;
+    path?: string;
+    podspec?: string;
+    testspecs?: string[];
+    git?: string;
+    branch?: string;
+    tag?: string;
+    commit?: string;
+}
+export type ExtraDependencies = AndroidMavenRepository[] | ApplePod[];
+/**
+ * Represents code signing entitlements passed to the `ExpoModulesProvider` for Apple platforms.
+ */
+export interface AppleCodeSignEntitlements {
+    /**
+     * @see https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_application-groups
+     */
+    appGroups?: string[];
+}
+export {};

package/example/node_modules/expo-modules-autolinking/e2e/TestUtils.ts

@@ -0,0 +1,53 @@
+import spawnAsync, { SpawnOptions, SpawnResult } from '@expo/spawn-async';
+import { spawnSync } from 'child_process';
+import { join } from 'path';
+
+export const AUTOLINKINNG_CLI = join(__dirname, '../bin/expo-modules-autolinking.js');
+
+function isSpawnResult(errorOrResult: Error): errorOrResult is Error & SpawnResult {
+  return 'pid' in errorOrResult && 'stdout' in errorOrResult && 'stderr' in errorOrResult;
+}
+
+export async function autolinkingRunAsync(
+  args: string[],
+  options?: SpawnOptions
+): Promise<SpawnResult> {
+  const promise = spawnAsync(AUTOLINKINNG_CLI, args, {
+    ...options,
+    env: { ...process.env, EXPO_SHOULD_USE_LEGACY_PACKAGE_INTERFACE: '1' },
+  });
+
+  try {
+    return await promise;
+  } catch (error) {
+    if (isSpawnResult(error)) {
+      if (error.stdout) error.message += `\n------\nSTDOUT:\n${error.stdout}`;
+      if (error.stderr) error.message += `\n------\nSTDERR:\n${error.stderr}`;
+    }
+    throw error;
+  }
+}
+
+// For some reason, it can't be async, cause otherwise we will get `yarn did not print valid JSON:` error
+export function yarnSync(options?: SpawnOptions) {
+  spawnSync('yarn', ['install', '--silent'], options);
+}
+
+export function combinations<T, U>(
+  aKey: string,
+  a: T[],
+  bKey: string,
+  b: U[]
+): { [key: string]: T | U }[] {
+  const result = [];
+  a.forEach(aValue => {
+    b.forEach(bValue => {
+      result.push({
+        [aKey]: aValue,
+        [bKey]: bValue,
+      });
+    });
+  });
+
+  return result;
+}

package/example/node_modules/expo-modules-autolinking/exports.d.ts

@@ -0,0 +1 @@
+export * from './build/autolinking';

package/example/node_modules/expo-modules-autolinking/src/ExpoModuleConfig.ts

@@ -0,0 +1,181 @@
+import {
+  AndroidGradleAarProjectDescriptor,
+  AndroidGradlePluginDescriptor,
+  AndroidPublication,
+  RawExpoModuleConfig,
+  RawModuleConfigApple,
+  SupportedPlatform,
+} from './types';
+
+function arrayize<T>(value: T[] | T | undefined): T[] {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value != null ? [value] : [];
+}
+
+export class ExpoAndroidProjectConfig {
+  constructor(
+    public name: string,
+    public path: string,
+    public modules?: string[],
+    public publication?: AndroidPublication,
+    public gradleAarProjects?: AndroidGradleAarProjectDescriptor[],
+    public shouldUsePublicationScriptPath?: string,
+    /**
+     * Whether this project is the root one.
+     */
+    public isDefault: boolean = false
+  ) {}
+}
+
+/**
+ * A class that wraps the raw config (`expo-module.json` or `unimodule.json`).
+ */
+export class ExpoModuleConfig {
+  constructor(readonly rawConfig: RawExpoModuleConfig) {}
+
+  /**
+   * Whether the module supports given platform.
+   */
+  supportsPlatform(platform: SupportedPlatform): boolean {
+    const supportedPlatforms = this.rawConfig.platforms ?? [];
+
+    if (platform === 'apple') {
+      // Apple platform is supported when any of iOS, macOS and tvOS is supported.
+      return supportedPlatforms.some((supportedPlatform) => {
+        return ['apple', 'ios', 'macos', 'tvos'].includes(supportedPlatform);
+      });
+    }
+    return supportedPlatforms.includes(platform);
+  }
+
+  /**
+   * Returns the generic config for all Apple platforms with a fallback to the legacy iOS config.
+   */
+  getAppleConfig(): RawModuleConfigApple | null {
+    return this.rawConfig.apple ?? this.rawConfig.ios ?? null;
+  }
+
+  /**
+   * Returns a list of names of Swift native modules classes to put to the generated modules provider file.
+   */
+  appleModules() {
+    const appleConfig = this.getAppleConfig();
+    return appleConfig?.modules ?? [];
+  }
+
+  /**
+   * Returns a list of names of Swift classes that receives AppDelegate life-cycle events.
+   */
+  appleAppDelegateSubscribers(): string[] {
+    return this.getAppleConfig()?.appDelegateSubscribers ?? [];
+  }
+
+  /**
+   * Returns a list of names of Swift classes that implement `ExpoReactDelegateHandler`.
+   */
+  appleReactDelegateHandlers(): string[] {
+    return this.getAppleConfig()?.reactDelegateHandlers ?? [];
+  }
+
+  /**
+   * Returns podspec paths defined by the module author.
+   */
+  applePodspecPaths(): string[] {
+    return arrayize(this.getAppleConfig()?.podspecPath);
+  }
+
+  /**
+   * Returns the product module names, if defined by the module author.
+   */
+  appleSwiftModuleNames(): string[] {
+    return arrayize(this.getAppleConfig()?.swiftModuleName);
+  }
+
+  /**
+   * Returns whether this module will be added only to the debug configuration
+   */
+  appleDebugOnly(): boolean {
+    return this.getAppleConfig()?.debugOnly ?? false;
+  }
+
+  /**
+   * Returns information about Android projects defined by the module author.
+   */
+  androidProjects(defaultProjectName: string): ExpoAndroidProjectConfig[] {
+    const androidProjects: ExpoAndroidProjectConfig[] = [];
+
+    // Adding the "root" Android project - it might not be valide.
+    androidProjects.push(
+      new ExpoAndroidProjectConfig(
+        this.rawConfig.android?.name ?? defaultProjectName,
+        this.rawConfig.android?.path ?? 'android',
+        this.rawConfig.android?.modules,
+        this.rawConfig.android?.publication,
+        this.rawConfig.android?.gradleAarProjects,
+        this.rawConfig.android?.shouldUsePublicationScriptPath,
+        !this.rawConfig.android?.path // it's default project because path is not defined
+      )
+    );
+
+    this.rawConfig.android?.projects?.forEach((project) => {
+      androidProjects.push(
+        new ExpoAndroidProjectConfig(
+          project.name,
+          project.path,
+          project.modules,
+          project.publication,
+          project.gradleAarProjects,
+          project.shouldUsePublicationScriptPath
+        )
+      );
+    });
+
+    return androidProjects;
+  }
+
+  /**
+   * Returns gradle plugins descriptors defined by the module author.
+   */
+  androidGradlePlugins(): AndroidGradlePluginDescriptor[] {
+    return arrayize(this.rawConfig.android?.gradlePlugins ?? []);
+  }
+
+  /**
+   * Returns gradle projects containing AAR files defined by the module author.
+   */
+  androidGradleAarProjects(): AndroidGradleAarProjectDescriptor[] {
+    return arrayize(this.rawConfig.android?.gradleAarProjects ?? []);
+  }
+
+  /**
+   * Returns the publication config for Android.
+   */
+  androidPublication(): AndroidPublication | undefined {
+    return this.rawConfig.android?.publication;
+  }
+
+  /**
+   * Returns core features required by the module author.
+   */
+  coreFeatures(): string[] {
+    return arrayize(this.rawConfig.coreFeatures ?? []);
+  }
+
+  /**
+   * Returns serializable raw config.
+   */
+  toJSON(): RawExpoModuleConfig {
+    return this.rawConfig;
+  }
+}
+
+/**
+ * Reads the config at given path and returns the config wrapped by `ExpoModuleConfig` class.
+ */
+export function requireAndResolveExpoModuleConfig(path: string): ExpoModuleConfig {
+  // TODO: Validate the raw config against a schema.
+  // TODO: Support for `*.js` files, not only static `*.json`.
+  return new ExpoModuleConfig(require(path) as RawExpoModuleConfig);
+}