amotify 0.0.2 → 0.0.4

package/dist/src/Global/@export.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import * as ReactDom from 'react-dom';
+import * as ReactRouterDom from 'react-router-dom';
+import { LaunchReactApplication } from './LaunchReactApplication';
+declare const useStore: amotify.glob.useStoreParams;
+declare const useRecycle: amotify.glob.useRecycleParams;
+declare const pageTransit: amotify.glob.PageTransitParams;
+declare const StyleConverter: {
+    ReadStyleSet: amotify.glob.StyleConverter.ReadStyleSet;
+    ToClassName: amotify.glob.StyleConverter.ToClassName;
+};
+export { React, ReactDom, ReactRouterDom, pageTransit, useStore, useRecycle, StyleConverter, LaunchReactApplication };

package/dist/src/Global/LaunchReactApplication.d.ts

@@ -0,0 +1 @@
+export declare const LaunchReactApplication: amotify.glob.LaunchReactApplicationParams;

package/dist/src/Global/styleConverter.d.ts

@@ -0,0 +1,2 @@
+export declare const ReadStyleSet: amotify.glob.StyleConverter.ReadStyleSet;
+export declare const ToClassName: amotify.glob.StyleConverter.ToClassName;

package/dist/src/Molecules/@export.d.ts

@@ -0,0 +1,21 @@
+import { List } from './List';
+import { Accordion } from './Accordion/parts';
+import { LinkifyText } from './LinkifyText/parts';
+declare const Text: {
+    Title: (params: amotify.atoms.BoxInput) => JSX.Element;
+    SubTitle: (params: amotify.atoms.BoxInput) => JSX.Element;
+    ThirdTitle: (params: amotify.atoms.BoxInput) => JSX.Element;
+    Paragraph: (params: amotify.atoms.BoxInput) => JSX.Element;
+    Normal: (params: amotify.atoms.BoxInput) => JSX.Element;
+    Description: (params: amotify.atoms.BoxInput) => JSX.Element;
+    Supplement: (params: amotify.atoms.BoxInput) => JSX.Element;
+    NowrapSpan: (params: amotify.atoms.SpanProps) => JSX.Element;
+};
+declare const Row: {
+    Center: (params: amotify.atoms.FlexProps) => JSX.Element;
+    Left: (params: amotify.atoms.FlexProps) => JSX.Element;
+    Right: (params: amotify.atoms.FlexProps) => JSX.Element;
+    Separate: (params: amotify.atoms.FlexProps) => JSX.Element;
+};
+declare const Column: (params: amotify.atoms.FlexProps) => JSX.Element;
+export { List, Accordion, LinkifyText, Text, Column, Row };

package/dist/src/Molecules/Accordion/parts.d.ts

@@ -0,0 +1,2 @@
+declare const Accordion: amotify.mols.Accordion.SetParams;
+export { Accordion };

package/dist/src/Molecules/LinkifyText/parts.d.ts

@@ -0,0 +1 @@
+export declare const LinkifyText: FNC<amotify.mols.LinkifyTextProps>;

package/dist/src/Molecules/List.d.ts

@@ -0,0 +1 @@
+export declare const List: FNC<amotify.mols.List.Params>;

package/dist/src/Organisms/@export.d.ts

@@ -0,0 +1,2 @@
+import { DisplayStyleInput } from './DisplayStyleInput/_';
+export { DisplayStyleInput };

package/dist/src/Organisms/DisplayStyleInput/_.d.ts

@@ -0,0 +1 @@
+export declare const DisplayStyleInput: amotify.orgs.DisplayStyleInput.Methods;

package/dist/src/Organisms/DisplayStyleInput/darkmode.d.ts

@@ -0,0 +1 @@
+export declare const Darkmode: (params: amotify.orgs.DisplayStyleInput.DarkmodeInput) => JSX.Element;

package/dist/src/Organisms/DisplayStyleInput/themeColor.d.ts

@@ -0,0 +1,27 @@
+export declare const Colors: {
+    Basics: ({
+        key: string;
+        icon: JSX.Element;
+    } | {
+        key: string;
+        icon: string;
+    })[];
+    Brands: {
+        key: string;
+        icon: JSX.Element;
+        label: string;
+    }[];
+    Originals: ({
+        key: string;
+        icon: string;
+        label?: undefined;
+    } | {
+        key: string;
+        icon: string;
+        label: string;
+    })[];
+};
+export declare const ThemeColorALL: FNC<amotify.orgs.DisplayStyleInput.ThemeColorInput>;
+export declare const ThemeColorBasic: FNC<amotify.orgs.DisplayStyleInput.ThemeColorInput>;
+export declare const ThemeColorOriginal: FNC<amotify.orgs.DisplayStyleInput.ThemeColorInput>;
+export declare const ThemeColorBrands: FNC<amotify.orgs.DisplayStyleInput.ThemeColorInput>;

package/dist/src/Templates/@export.d.ts

@@ -0,0 +1,2 @@
+import { PlayGround } from './PlayGround/parts';
+export { PlayGround };

package/dist/src/Templates/PlayGround/parts.d.ts

@@ -0,0 +1 @@
+export declare const PlayGround: FNC<{}>;

package/dist/src/config.d.ts

@@ -0,0 +1,16 @@
+export declare const script: HTMLOrSVGScriptElement | null;
+export declare const fileName: string | null | undefined;
+export declare const Version: string;
+export declare const userAgent: string;
+export declare const deviceType: string;
+export declare const deviceIdentifier: () => {
+    isWhat: "Windows";
+    isTouchDevice: boolean;
+    isPhone: boolean;
+    isIOS: boolean;
+    isSystemDarkmode: () => boolean;
+    isBreakpoint: () => boolean;
+    isPhonepoint: () => boolean;
+};
+export declare const SetThemeColorTag: () => void;
+export declare const defaultConfig: amotify.config.Methods;

package/dist/src/launch.d.ts

@@ -0,0 +1,9 @@
+import 'jsmin-front/dist/@types';
+import './@types/_';
+declare let publicURI: string;
+export { publicURI };
+import './@jsminAmotifyExtension/_';
+declare const amotify: amotify;
+export { amotify };
+import './@styles/@app.scss';
+import './preload';

package/dist/src/preload.d.ts

@@ -0,0 +1 @@
+declare let tags: Jsmin.CreateElement.Args[];

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "amotify",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "UI Component for React",
   "main": "dist/launch.js",
   "types": "dist/@types.d.ts",
   "scripts": {
-    "clean-cdn": "rimraf cdn",
+    "clean-cdn": "rimraf public",
     "clean-dist": "rimraf dist",
     "devCDN:webpack": "webpack --mode development --watch",
     "devCDN:server": "nodemon app.js --ignore public --ignore package.json --ignore src --ignore webpack.config.js --ignore tsconfig.json",

package/src/@jsminAmotifyExtension/_.tsx

@@ -0,0 +1,4 @@
+import './variables';
+import './fetch';
+import './formCollect';
+import './spreadSheet';

package/src/@jsminAmotifyExtension/fetch.tsx

@@ -0,0 +1,107 @@
+const fetcher = async ( params: JsminExtension.Fetch.Input & {
+  method: string
+},callback?: JsminExtension.Fetch.callback ) => {
+  let {
+    method,
+    key = $.uuidGen( 16 ),
+    url = '',
+    trafficControl = 500,
+    // trafficControl = 1000,
+    preventMultiRequest = true,
+    topLoader = false,
+    cornerLoader = true,
+    ...Params
+  } = params || {}
+
+  let result: Jsmin.Fetch.Output = await ( async () => {
+    let exist = $.fetch.waitList.includes( key );
+
+    if ( preventMultiRequest && exist ) {
+      return {
+        ok: false,
+        status: 405,
+        statusText: 'NoAcceptedMultiRequests',
+        body: 'NoAcceptedMultiRequests',
+        requestTime: 0,
+        rawData: null as any
+      }
+    }
+
+    $.fetch.waitList = [ ...$.fetch.waitList,key ];
+
+    if ( !url.match( /https?:/ ) ) {
+      url = '/' + url.replace( /^\//,"" );
+
+      Params.headers = {
+        ...$.fetch.defaultHeaders || {},
+        ...Params.headers || {}
+      }
+    }
+
+    amotify.fn.Loader.fn.mini.active( params.key || '' );
+    !topLoader || amotify.fn.Loader.fn.top.active();
+    !cornerLoader || amotify.fn.Loader.fn.corner.active();
+
+    let result = await $.ajax( {
+      method,
+      url,
+      ...Params
+    } );
+    if ( $.fetch.defaultResultCallback ) $.fetch.defaultResultCallback( result );
+
+    if ( trafficControl ) {
+      let { requestTime } = result;
+      if ( requestTime <= trafficControl ) {
+        let CoolDownTime = Number( trafficControl - requestTime );
+        await ( () => {
+          result.requestTime = trafficControl;
+          return new Promise( ( resolve,reject ) => {
+            setTimeout( () => {
+              resolve( void 0 );
+            },CoolDownTime );
+          } );
+        } )();
+      }
+    }
+
+    amotify.fn.Loader.fn.mini.stop( params.key || '' );
+    !topLoader || amotify.fn.Loader.fn.top.stop();
+    !cornerLoader || amotify.fn.Loader.fn.corner.stop();
+    $.fetch.waitList.splice( $.fetch.waitList.findIndex( ( a ) => a == key ),1 );
+    return result;
+  } )();
+
+  if ( callback ) callback( result );
+  return result;
+}
+
+$.fetch = {
+  get: async ( params,callback ) => {
+    return await fetcher( { ...params,method: 'get' },callback );
+  },
+  post: async ( params,callback ) => {
+    return await fetcher( { ...params,method: 'post' },callback );
+  },
+  options: async ( params,callback ) => {
+    return await fetcher( { ...params,method: 'options' },callback );
+  },
+  put: async ( params,callback ) => {
+    return await fetcher( { ...params,method: 'put' },callback );
+  },
+  waitList: [],
+  defaultHeaders: {},
+  defaultResultCallback: ( result ) => {
+    let {
+      status,
+      statusText
+    } = result;
+    if ( status == 500 ) {
+      $.NoticeHttpStatus( {
+        status,statusText,
+        label: <>
+          Internal Server Error
+        </>
+      } );
+    }
+  }
+}

package/src/@jsminAmotifyExtension/formCollect.tsx

@@ -0,0 +1,89 @@
+import {
+  useStore
+} from '@global';
+
+let formProcess = false;
+$.formCollect = async ( form ) => {
+  if ( formProcess ) return {
+    valid: false,
+    data: {}
+  }
+
+  let focusElement: HTMLElement = document.activeElement as any;
+  if ( focusElement ) focusElement.blur();
+
+  formProcess = true;
+  let Inputs = $( `[data-form="${ form }"]` ),
+    totalValid = 1,
+    Values: plainObject = {}
+
+  for ( let index = 0; index < Inputs.length; index++ ) {
+    let Input = Inputs[ index ];
+
+    let { componentId = '' } = Input.dataset;
+    let componentData = useStore.get( componentId );
+
+    if ( componentData && componentData.Refresh ) await componentData.Refresh();
+
+    let {
+      value: displayValue,
+      name,
+      checked,
+      dataset: {
+        value,
+        inputType = '',
+        validation
+      }
+    } = Inputs[ index ] as any;
+    let Value: any = value;
+
+    validation = Number( ( validation ?? 'true' ) == 'true' );
+
+    if ( inputType == 'hidden' ) {
+      if ( Value ) Value = JSON.parse( Value );
+    } else if ( [ 'radio','checkbox','checker' ].includes( inputType ) ) {
+      if ( Value ) {
+        Value = JSON.parse( Value );
+        if ( $.is.array( Value ) ) {
+          Value = Value.map( ( v ) => JSON.parse( v ) )
+        } else {
+          Value = JSON.parse( Value );
+        }
+        if ( inputType == 'radio' ) {
+          Value = Value[ 0 ];
+        }
+        if ( inputType == 'checker' ) {
+          Value = Boolean( Value[ 0 ] );
+        }
+      }
+    } else if ( [ 'chips-single','chips-multi' ].includes( inputType ) ) {
+      Value = JSON.parse( Value );
+      if ( Value.length ) {
+        if ( inputType == 'chips-single' ) Value = Value[ 0 ];
+      }
+    } else if ( inputType == 'time' ) {
+      if ( Value ) Value = JSON.parse( Value );
+    } else if ( inputType == 'select' ) {
+      if ( Value ) Value = JSON.parse( Value );
+    } else if ( inputType == 'file' ) {
+      if ( componentData ) {
+        let files = componentData.Files;
+        Value = files;
+      }
+    } else if ( inputType == 'slider' ) {
+      if ( Value ) Value = JSON.parse( Value );
+    } else if ( inputType == 'switch' ) {
+      Value = checked | 0;
+    }
+    let valid = ( validation ?? 1 ) | 0;
+    totalValid &= valid;
+
+    if ( validation ) Values[ name ] = Value;
+  }
+
+  formProcess = false;
+  return {
+    valid: Boolean( totalValid ),
+    data: Values
+  };
+}

package/src/@jsminAmotifyExtension/spreadSheet.tsx

@@ -0,0 +1,159 @@
+export { }
+import { publicURI } from '../launch';
+
+declare global {
+  var ExcelJS: any;
+}
+{
+  const D: JsminExtension.SpreadSheet.Instance = ( wb,fn ) => {
+    return new ( D.fn as any ).SpreadSheet( wb,fn );
+  }
+  D.fn = D.prototype = {} as any
+  $.extend( {
+    SpreadSheet: function ( workbook: JsminExtension.SpreadSheet.Method,fileName: string ) {
+      this.workbook = workbook;
+      this.fileName = fileName;
+      return this;
+    },
+    getWorkbook: function () {
+      return this.workbook;
+    },
+    updateFileName: function ( fileName: string ) {
+      this.fileName = fileName;
+      return this;
+    },
+    updateMerges: function ( merges: JsminExtension.SpreadSheet.MergeTypes[][] ) {
+      let json = this.toJson() as JsminExtension.SpreadSheet.JsonTypes;
+      json.sheets.forEach( ( sheet,index ) => {
+        let sheetMerges = merges[ index ];
+        const worksheet = this.workbook.getWorksheet( sheet.sheetName );
+        for ( let [ from,to ] of sheetMerges ) {
+          if ( from && to ) worksheet.mergeCells( from + ':' + to );
+        }
+      } );
+    },
+    updateStyles: function ( styles: JsminExtension.SpreadSheet.StyleTypes[][] ) {
+      let json = this.toJson() as JsminExtension.SpreadSheet.JsonTypes;
+      json.sheets.forEach( ( sheet,index ) => {
+        let sheetStyles = styles[ index ];
+        const worksheet = this.workbook.getWorksheet( sheet.sheetName );
+        for ( let style of sheetStyles ) {
+          let {
+            type,
+            target,
+            values
+          } = style;
+          let Targets = $.flatArray( target );
+
+          for ( let [ key,value ] of Object.entries( values ) )
+            for ( let Target of Targets )
+              worksheet[ 'get' + type.toCapital() ]( Target )[ key ] = value;
+        }
+      } );
+    },
+    toJson: function () {
+      let json: any = {
+        fileName: this.fileName,
+        sheets: []
+      };
+      this.workbook.eachSheet( ( sheet: any,id: any ) => {
+        let sheetJson: any = {
+          sheetName: sheet.name,
+          rows: []
+        };
+        sheet.eachRow( ( row: any,rowIndex: any ) => {
+          let [ emp,...values ] = row.values;
+          sheetJson.rows.push( values );
+        } );
+        json.sheets.push( sheetJson );
+      } );
+      return json;
+    },
+    export: async function ( fileType?: 'xlsx' | 'csv' ) {
+      fileType = fileType || 'xlsx';
+
+      const uint8Array = await this.workbook[ fileType ].writeBuffer();
+      const blob = new Blob( [ uint8Array ],{ type: 'application/octet-binary' } );
+      const dummyAnchor = document.createElement( 'a' );
+      dummyAnchor.href = ( window.URL || window.webkitURL ).createObjectURL( blob );
+      dummyAnchor.download = this.fileName + '.' + fileType;
+      dummyAnchor.click();
+      dummyAnchor.remove();
+    },
+  },D );
+
+  ( D.fn as any ).SpreadSheet.prototype = D.fn;
+  ( D.fn as any ).SpreadSheet.prototype.constructor = D;
+
+  $.spreadSheet = {
+    readFromFile: async ( file ) => {
+      if ( !window.ExcelJS ) {
+        await amotify.config.readExtraCDN( publicURI + '@env/@foreign/exceljs.min.js' );
+      }
+      if ( !window.ExcelJS ) return;
+
+      const workbook = new ExcelJS.Workbook();
+      let readFile = await file.read( 'binaryString' );
+      const buffer = ( readFile as any ).target.result;
+      let fileName = file.name.replace( /\.[^/.]+$/,'' );
+      return D( await workbook.xlsx.load( buffer ),fileName );
+    },
+    readFromJson: async ( params ) => {
+      if ( !window.ExcelJS ) {
+        await amotify.config.readExtraCDN( publicURI + '@env/@foreign/exceljs.min.js' );
+      }
+      if ( !window.ExcelJS ) return;
+
+      let {
+        sheets,
+        fileName = ''
+      } = params;
+      fileName = fileName || $.uuidGen();
+
+      const workbook = new ExcelJS.Workbook();
+
+      sheets.forEach( ( sheet,index ) => {
+        let {
+          sheetName,
+          headers = [],
+          rows,
+          merges = [],
+          styles = []
+        } = sheet;
+        sheetName = sheetName || 'シート' + ( index + 1 );
+
+        workbook.addWorksheet( sheetName );
+        const worksheet = workbook.getWorksheet( sheetName );
+
+        let Headers = headers.map( ( header,index ) => {
+          let { key,value } = header;
+          return {
+            key: key,
+            header: value
+          }
+        } );
+
+        worksheet.columns = Headers;
+        worksheet.addRows( rows );
+
+        for ( let [ from,to ] of merges ) {
+          if ( from && to ) worksheet.mergeCells( from + ':' + to );
+        }
+        for ( let style of styles ) {
+          let {
+            type,
+            target,
+            values
+          } = style;
+          let Targets = $.flatArray( target );
+
+          for ( let [ key,value ] of Object.entries( values ) )
+            for ( let Target of Targets )
+              worksheet[ 'get' + type.toCapital() ]( Target )[ key ] = value;
+        }
+      } );
+
+      return D( workbook,fileName );
+    }
+  }
+}

package/src/@jsminAmotifyExtension/variables.tsx

@@ -0,0 +1,130 @@
+$.NoticeHttpStatus = ( params ) => {
+  let {
+    status,
+    statusText,
+    label,
+    ...others
+  } = params;
+
+  if ( status >= 400 ) {
+    others = {
+      backgroundColor: 'nega',
+      ...others,
+    }
+  }
+
+  amotify.fn.SnackBar.add( {
+    children: <amotify.atoms.Box>
+      <amotify.mols.Text.Paragraph>
+        通信ステータス : { status } { statusText }
+      </amotify.mols.Text.Paragraph>
+      <amotify.mols.Text.Normal>
+        { label }
+      </amotify.mols.Text.Normal>
+    </amotify.atoms.Box>,
+    ...others
+  } );
+}
+$.copyToClipboard = async ( rawData ) => {
+  let data = '';
+  if ( $.is.string( rawData ) ) data = rawData
+  else if ( $.is.function( rawData ) ) data = rawData() as any;
+
+  let response = {
+    ok: false,
+    body: 'NotSupported'
+  }
+
+  await ( async () => {
+    let result;
+    if ( navigator.clipboard ) {
+      result = await navigator
+        .clipboard
+        .writeText( data )
+        .then(
+          () => true,
+          () => false
+        )
+      if ( !result ) return;
+    } else {
+      let input = document.createElement( 'input' );
+      $( document.body ).append( input );
+      input.value = data;
+      input.select();
+      result = document.execCommand( 'copy' );
+      document.body.removeChild( input );
+
+      if ( !result ) return;
+    }
+
+    amotify.fn.SnackBar.add( {
+      children: 'クリップボードにコピーしました'
+    } );
+    response = {
+      ok: true,
+      body: ''
+    };
+  } )();
+
+  return response;
+}
+$.isJSXElement = function ( v ): v is JSX.Element {
+  return v.$$typeof === Symbol.for( 'react.element' );
+}
+$.getCurrentLocation = () => {
+  return new Promise( ( resolve,reject ) => {
+    navigator.geolocation.getCurrentPosition( ( position ) => {
+      let {
+        latitude,
+        longitude
+      } = position.coords;
+      resolve( {
+        ok: true,
+        status: 200,
+        body: {
+          lat: latitude,
+          lng: longitude
+        }
+      } );
+    },( error ) => {
+      resolve( {
+        ok: false,
+        status: 500,
+        body: {
+          reason: error
+        }
+      } );
+    } );
+  } );
+}
+$.CDNReader = ( url ) => {
+  return new Promise( ( resolve,reject ) => {
+    let tag = document.createElement( 'script' );
+    tag.src = url;
+    tag.addEventListener( 'load',() => {
+      resolve( 'OK' );
+    } );
+    $( document.body ).append( tag );
+  } );
+}
+$.ImageLoader = ( dataUrl,img ) => {
+  return new Promise( ( resolve,reject ) => {
+    let Img = img ? img : new Image();
+    Img.onload = () => resolve( Img );
+    Img.onerror = ( e ) => reject( e );
+    Img.src = dataUrl;
+  } );
+}
+$.extend( {
+  zen2hanNumber: function ( this: string ) {
+    return this.replace( /[０-９]/g,function ( s: any ) {
+      return String.fromCharCode( s.charCodeAt( 0 ) - 0xFEE0 );
+    } )
+      .replace( /[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]/g,'-' )
+      .replace( /￥/,'¥' )
+      .replace( /、/,',' )
+      .replace( /（/,'(' )
+      .replace( /）/,')' )
+      .replace( /＋/,'+' );
+  }
+},String );

package/src/@styles/@app.scss

@@ -0,0 +1,4 @@
+@use './@variables/customProps' as *;
+@forward './@variables/var';
+@forward './init';
+@forward './UniStyling';